Housekeeping

Author: MrTalon63

bun.lock

@@ -29,7 +29,6 @@
 		"pino": "^10.3.1",
 		"pino-loki": "^3.0.0",
 		"pino-pretty": "^13.1.3",
-		"prom-client": "^15.1.3",
 		"tle": "^3.0.1"
 	}
 }

package.json

@@ -1,11 +1,14 @@
 import { Elysia } from "elysia";
 
 import tleGetter from "../utils/tleGetter";
+import limiter from "../utils/ratelimiter";
 
-const noradRoute = new Elysia({ prefix: "/norad" }).get("/:id", async ({ params }) => {
-	const noradId = parseInt(params.id, 10);
-	const tleData = await tleGetter(noradId);
-	return new Response(tleData, { headers: { "Content-Type": "text/plain", "Cache-Control": "max-age=3600" } });
-});
+const noradRoute = new Elysia({ prefix: "/norad" })
+	.use(limiter)
+	.get("/:id", async ({ params }) => {
+		const noradId = parseInt(params.id, 10);
+		const tleData = await tleGetter(noradId);
+		return new Response(tleData, { headers: { "Content-Type": "text/plain", "Cache-Control": "max-age=3600" } });
+	});
 
 export default noradRoute;

src/routes/norad.ts

@@ -24,14 +24,14 @@ async function handleGroupRequest(group: string, lastFetchedHeader: number, form
 		log.debug(`No cached GP data for group "${group}", format "${format}". Fetching from Celestrak...`);
 		tle = await tleFetcher(group, format);
 		timestamp = now;
-		kv.set(`${group}_${format}`, tle);
-		kv.set(`${group}_timestamp_${format}`, timestamp);
+		await kv.set(`${group}_${format}`, tle);
+		await kv.set(`${group}_timestamp_${format}`, timestamp);
 	} else if (isStale) {
 		log.debug(`GP data for group "${group}", format "${format}" are stale. Fetching fresh TLEs...`);
 		tle = await tleFetcher(group, format);
 		timestamp = now;
-		kv.set(`${group}_${format}`, tle);
-		kv.set(`${group}_timestamp_${format}`, timestamp);
+		await kv.set(`${group}_${format}`, tle);
+		await kv.set(`${group}_timestamp_${format}`, timestamp);
 	} else {
 		log.debug(`Serving cached GP data for group "${group}", format "${format}".`);
 	}

src/utils/groupHandler.ts

@@ -2,13 +2,14 @@ import { Elysia } from "elysia";
 
 import kv from "./kv";
 import log from "./logger";
+import config from "./config";
 
 const limiter = new Elysia({ name: "rate-limiter" }).onRequest(async (ctx) => {
 	const ip = ctx.request.headers.get("x-forwarded-for") || ctx.request.headers.get("cf-connecting-ip") || ctx.request.headers.get("true-client-ip") || ctx.request.headers.get("x-real-ip") || "unknown";
 	const key = `rate_limit:${ip}`;
 	const now = Date.now();
-	const windowSize = process.env.RATE_LIMIT_WINDOW ? parseInt(process.env.RATE_LIMIT_WINDOW) * 1000 : 60 * 1000;
-	const maxRequests = process.env.RATE_LIMIT_MAX_REQUESTS ? parseInt(process.env.RATE_LIMIT_MAX_REQUESTS) : 60;
+	const windowSize = config.rateLimitWindow;
+	const maxRequests = config.rateLimitMaxRequests;
 
 	let clientInfo = await kv.get(key);
 	if (!clientInfo) {

src/utils/metrics.ts

@@ -14,10 +14,20 @@ async function fetchTle(group: string, format: "tle" | "json" | "csv" = "tle"):
 				"User-Agent": `ReTLEctor/${version} (https://github.com/MrTalon63/ReTLEctor)`,
 			},
 		});
+
+		if (response.status === 304) {
+			const cached = (await kv.get(`${group}_${format}`)) as string | null;
+			if (cached) {
+				log.debug(`Celestrak returned 304 for group "${group}", format "${format}". Serving cached data.`);
+				return cached;
+			}
+			throw new Error(`Celestrak returned 304 but no cached data exists for group "${group}", format "${format}"`);
+		}
 		if (!response.ok) {
 			throw new Error(`Failed to fetch TLEs: ${response.status} ${response.statusText}`);
 		}
 		const tleData = await response.text();
+
 		await kv.set(`${group}_${format}`, tleData);
 		await kv.set(`${group}_timestamp_${format}`, Date.now());
 		log.debug(`Successfully cached TLEs for group "${group}" in format "${format}".`);

src/utils/ratelimiter.ts

@@ -14,33 +14,58 @@ async function getObjectsTle(noradId: number) {
 
 	if (!tleData || isStale) {
 		let allTles = (await kv.get("active_tle")) as string | null;
-		if (!allTles) {
+		const activeTimestamp: number | undefined = await kv.get("active_timestamp_tle");
+		const activeIsStale = activeTimestamp ? now - activeTimestamp > config.cacheActiveDuration : true;
+
+		if (!allTles || activeIsStale) {
+			// Active group is missing or stale — fetch fresh data and re-cache all satellites
 			await fetchTle("active");
-		}
-		allTles = (await kv.get("active_tle")) as string | null;
+			allTles = (await kv.get("active_tle")) as string | null;
 
-		// If we still don't have the active TLEs then something went wrong with fetching, so we throw an error
-		if (!allTles) {
-			log.error("Failed to fetch active TLEs from Celestrak");
-			throw new Error("Failed to fetch active TLEs from Celestrak");
-		}
-		const lines = allTles.split("\n");
-		const setPromises: Promise<boolean>[] = [];
-		for (let i = 0; i < lines.length; i += 3) {
-			const idLine = lines[i + 0];
-			const tleLine1 = lines[i + 1];
-			const tleLine2 = lines[i + 2];
-
-			if (idLine && tleLine1 && tleLine2) {
-				const parsed = tle.parse(`${idLine}\n${tleLine1}\n${tleLine2}`);
-				const tleString = `${idLine}\n${tleLine1}\n${tleLine2}`;
-				if (parsed.number === noradId) {
-					tleData = tleString;
+			// If we still don't have the active TLEs then something went wrong with fetching, so we throw an error
+			if (!allTles) {
+				log.error("Failed to fetch active TLEs from Celestrak");
+				throw new Error("Failed to fetch active TLEs from Celestrak");
+			}
+
+			const lines = allTles.split("\n");
+			const setPromises: Promise<boolean>[] = [];
+			for (let i = 0; i < lines.length; i += 3) {
+				const idLine = lines[i + 0];
+				const tleLine1 = lines[i + 1];
+				const tleLine2 = lines[i + 2];
+
+				if (idLine && tleLine1 && tleLine2) {
+					const parsed = tle.parse(`${idLine}\n${tleLine1}\n${tleLine2}`);
+					const tleString = `${idLine}\n${tleLine1}\n${tleLine2}`;
+					if (parsed.number === noradId) {
+						tleData = tleString;
+					}
+					setPromises.push(kv.set(`tle_${parsed.number}`, tleString));
+					setPromises.push(kv.set(`tle_${parsed.number}_timestamp`, now));
+				}
+			}
+			await Promise.all(setPromises);
+		} else {
+			// Active group is still fresh — just scan for the requested satellite without re-writing everything
+			log.debug(`Active TLE group is fresh. Scanning for NORAD ID ${noradId} without re-caching all satellites.`);
+			const lines = allTles.split("\n");
+			for (let i = 0; i < lines.length; i += 3) {
+				const idLine = lines[i + 0];
+				const tleLine1 = lines[i + 1];
+				const tleLine2 = lines[i + 2];
+
+				if (idLine && tleLine1 && tleLine2) {
+					const parsed = tle.parse(`${idLine}\n${tleLine1}\n${tleLine2}`);
+					if (parsed.number === noradId) {
+						tleData = `${idLine}\n${tleLine1}\n${tleLine2}`;
+						await kv.set(`tle_${noradId}`, tleData);
+						await kv.set(`tle_${noradId}_timestamp`, now);
+						break;
+					}
 				}
-				setPromises.push(kv.set(`tle_${parsed.number}`, tleString));
 			}
 		}
-		await Promise.all(setPromises);
 	}
 
 	// If we're here then active group doesn't contain the requested NORAD ID, try fetching the TLE directly from Celestrak, but be aware of rate limits so we don't get blocked
@@ -77,6 +102,7 @@ async function getObjectsTle(noradId: number) {
 
 			tleData = (await response.text()) as string;
 			await kv.set(`tle_${noradId}`, tleData);
+			await kv.set(`tle_${noradId}_timestamp`, Date.now());
 			await kv.set(`celestrakTries`, tries + 1);
 			await kv.set(`celestrakLastTry`, Date.now());
 			log.debug(`Successfully fetched TLE for NORAD ID ${noradId} from Celestrak.`);