feat(dev): don't use Redis for dev purposes

Author: WarningImHack3r

src/lib/server/cache-handler.ts

@@ -0,0 +1,85 @@
+import type { Redis } from "@upstash/redis";
+
+export type RedisJson = Parameters<InstanceType<typeof Redis>["json"]["set"]>[2];
+
+export class CacheHandler {
+	readonly #redis: Redis;
+	readonly #memoryCache: Map<string, { value: unknown; expiresAt: number | null }>;
+	readonly #isDev: boolean;
+
+	/**
+	 * Initialize the cache handler
+	 *
+	 * @param redis the Redis instance
+	 * @param isDev whether we're in dev or prod
+	 */
+	constructor(redis: Redis, isDev: boolean) {
+		this.#redis = redis;
+		this.#memoryCache = new Map();
+		this.#isDev = isDev;
+	}
+
+	/**
+	 * Get a value from the cache
+	 *
+	 * @param key the key to get the result for
+	 * @returns the cached value, or `null` if not present
+	 */
+	async get<T extends RedisJson>(key: string) {
+		if (this.#isDev) {
+			console.log(`Retrieving ${key} from in-memory cache`);
+			// In dev mode, use memory cache only
+			const entry = this.#memoryCache.get(key);
+
+			if (!entry) {
+				console.log("Nothing to retrieve");
+				return null;
+			}
+
+			// Check if entry is expired
+			if (entry.expiresAt && entry.expiresAt < Date.now()) {
+				console.log("Value expired, purging and returning null");
+				this.#memoryCache.delete(key);
+				return null;
+			}
+
+			console.log("Returning found value from in-memory cache");
+			return entry.value as T;
+		}
+
+		// In production, use Redis
+		try {
+			return await this.#redis.json.get<T>(key);
+		} catch (error) {
+			console.error("Redis get error:", error);
+			return null;
+		}
+	}
+
+	/**
+	 * Set a value in the cache
+	 *
+	 * @param key the key to store the value for
+	 * @param value the value to store
+	 * @param ttlSeconds the optional TTL to set for expiration
+	 */
+	async set<T extends RedisJson>(key: string, value: T, ttlSeconds?: number) {
+		if (this.#isDev) {
+			console.log(`Setting value for ${key} in memory cache`);
+			// In dev mode, use memory cache only
+			const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1000 : null;
+			if (expiresAt) {
+				console.log(`Defining cache for ${key}, expires at ${new Date(expiresAt)}`);
+			} else console.log(`No cache set for ${key}`);
+			this.#memoryCache.set(key, { value, expiresAt });
+		} else {
+			// In production, use Redis
+			try {
+				await this.#redis.json.set(key, "$", value);
+				if (ttlSeconds) await this.#redis.expire(key, ttlSeconds);
+			} catch (error) {
+				console.error("Redis set error:", error);
+			}
+		}
+	}
+}

src/lib/server/github-cache.ts

@@ -1,3 +1,4 @@
+import { dev } from "$app/environment";
 import { GITHUB_TOKEN, KV_REST_API_TOKEN, KV_REST_API_URL } from "$env/static/private";
 import type {
 	CommentAuthorAssociation,
@@ -8,6 +9,7 @@ import { Octokit } from "octokit";
 import parseChangelog from "$lib/changelog-parser";
 import type { Repository } from "$lib/repositories";
 import type { Issues, Pulls } from "$lib/types";
+import { CacheHandler, type RedisJson } from "./cache-handler";
 
 /**
  * A strict version of Extract.
@@ -159,7 +161,7 @@ const DEPRECATIONS_TTL = 60 * 60 * 24 * 2; // 2 days
  * with an additional caching mechanism.
  */
 export class GitHubCache {
-	readonly #redis: Redis;
+	readonly #cache: CacheHandler;
 	readonly #octokit: Octokit;
 
 	/**
@@ -171,10 +173,13 @@ export class GitHubCache {
 	 * @constructor
 	 */
 	constructor(redisUrl: string, redisToken: string, githubToken: string) {
-		this.#redis = new Redis({
-			url: redisUrl,
-			token: redisToken
-		});
+		this.#cache = new CacheHandler(
+			new Redis({
+				url: redisUrl,
+				token: redisToken
+			}),
+			dev
+		);
 
 		this.#octokit = new Octokit({
 			auth: githubToken
@@ -238,7 +243,7 @@ export class GitHubCache {
 	 * @returns a currying promise than handles everything needed for requests
 	 * @private
 	 */
-	#processCached<RType extends Parameters<InstanceType<typeof Redis>["json"]["set"]>[2]>() {
+	#processCached<RType extends RedisJson>() {
 		/**
 		 * Inner currying function to circumvent unsupported partial inference
 		 *
@@ -255,7 +260,7 @@ export class GitHubCache {
 			transformer: (from: Awaited<PromiseType>) => RType | Promise<RType>,
 			ttl: number | ((value: RType) => number | undefined) | undefined = undefined
 		): Promise<RType> => {
-			const cachedValue = await this.#redis.json.get<RType>(cacheKey);
+			const cachedValue = await this.#cache.get<RType>(cacheKey);
 			if (cachedValue) {
 				console.log(`Cache hit for ${cacheKey}`);
 				return cachedValue;
@@ -265,17 +270,15 @@ export class GitHubCache {
 
 			const newValue = await transformer(await promise());
 
-			await this.#redis.json.set(cacheKey, "$", newValue);
+			let ttlResult: number | undefined = undefined;
 			if (ttl !== undefined) {
 				if (typeof ttl === "function") {
-					const ttlResult = ttl(newValue);
-					if (ttlResult !== undefined) {
-						await this.#redis.expire(cacheKey, ttlResult);
-					}
+					ttlResult = ttl(newValue);
 				} else {
-					await this.#redis.expire(cacheKey, ttl);
+					ttlResult = ttl;
 				}
 			}
+			await this.#cache.set(cacheKey, newValue, ttlResult);
 
 			return newValue;
 		};

src/routes/package/SidePanel.svelte

@@ -96,8 +96,7 @@
 		if (!lastVisitedItem) {
 			return releases.filter(
 				({ created_at, published_at }) =>
-					new Date(published_at ?? created_at).getTime() >
-					new Date().getTime() - 1000 * 60 * 60 * 24 * 7
+					new Date(published_at ?? created_at).getTime() > Date.now() - 1000 * 60 * 60 * 24 * 7
 			);
 		}
 		const lastVisitedDate = new Date(lastVisitedItem);

src/routes/package/[...package]/+page.svelte

@@ -125,7 +125,7 @@
 					// Only expand releases that are less than a week old
 					.filter(
 						({ created_at }) =>
-							new Date(created_at).getTime() > new Date().getTime() - 1000 * 60 * 60 * 24 * 7
+							new Date(created_at).getTime() > Date.now() - 1000 * 60 * 60 * 24 * 7
 					)
 					.map(({ id }) => id.toString())}
 				class="w-full space-y-2"

src/routes/package/[...package]/ReleaseCard.svelte

@@ -56,9 +56,7 @@
 			semVersion?.patch === 0 &&
 			!semVersion?.prerelease.length
 	);
-	let isOlderThanAWeek = $derived(
-		releaseDate.getTime() < new Date().getTime() - 1000 * 60 * 60 * 24 * 7
-	);
+	let isOlderThanAWeek = $derived(releaseDate.getTime() < Date.now() - 1000 * 60 * 60 * 24 * 7);
 
 	/**
 	 * Converts a date to a relative date string.
@@ -69,7 +67,7 @@
 	 * @returns the relative date
 	 */
 	function timeAgo(date: Date, locale = "en") {
-		const diff = (new Date().getTime() - date.getTime()) / 1000;
+		const diff = (Date.now() - date.getTime()) / 1000;
 		const minutes = Math.floor(diff / 60);
 		const hours = Math.floor(minutes / 60);
 		const days = Math.floor(hours / 24);

src/routes/tracker/[org]/[repo]/+page.svelte

@@ -22,7 +22,7 @@
 	 * @returns if it is more recent than a month
 	 */
 	function isNew(date: Date) {
-		return date.getTime() >= new Date().getTime() - 1000 * 60 * 60 * 24 * 30;
+		return date.getTime() >= Date.now() - 1000 * 60 * 60 * 24 * 30;
 	}
 
 	/**
@@ -32,7 +32,7 @@
 	 * @returns the formatted string output
 	 */
 	function daysAgo(date: Date) {
-		const days = Math.floor((new Date().getTime() - date.getTime()) / 1000 / 60 / 60 / 24);
+		const days = Math.floor((Date.now() - date.getTime()) / 1000 / 60 / 60 / 24);
 		return new Intl.RelativeTimeFormat("en", { numeric: "auto" }).format(-days, "day");
 	}