refactor: use sqlite for storage

Author: kane50613

.gitignore

@@ -173,3 +173,5 @@ dist
 
 # Finder (MacOS) folder config
 .DS_Store
+
+sqlite.db

bun.lockb

@@ -12,6 +12,6 @@
     "typescript": "^5.7.2"
   },
   "dependencies": {
-    "file-system-cache": "^3.0.0-alpha.8"
+    "xxhash-wasm": "^1.1.0"
   }
 }

package.json

@@ -0,0 +1,68 @@
+import xxhash from "xxhash-wasm";
+import { Database } from "bun:sqlite";
+
+const hasher = await xxhash();
+
+const db = new Database("sqlite.db", {
+  create: true,
+  strict: true,
+});
+
+type CachedResponse = {
+  key: bigint;
+  body?: Uint8Array;
+  timestamp: number;
+  status: number;
+  contentType?: string;
+};
+
+db.query(
+  `
+  CREATE TABLE IF NOT EXISTS cache (
+    key INTEGER PRIMARY KEY,
+    body BLOB,
+    status INTEGER NOT NULL,
+    timestamp INTEGER NOT NULL,
+    contentType TEXT
+  )
+`
+).run();
+
+const getCachedQuery = db.prepare<CachedResponse, CachedResponse["key"]>(
+  `SELECT * FROM cache WHERE key = ? AND timestamp > (strftime('%s', 'now') - 60 * 5)`
+);
+
+const setCachedQuery = db.prepare<
+  undefined,
+  Omit<CachedResponse, "timestamp">
+>(`
+  INSERT OR REPLACE INTO cache (key, body, status, contentType, timestamp)
+  VALUES ($key, $body, $status, $contentType, strftime('%s', 'now'))
+`);
+
+export function getCachedResponse(cacheKey: bigint) {
+  return getCachedQuery.get(cacheKey);
+}
+
+export function setCachedResponse(
+  cachedResponse: Omit<CachedResponse, "timestamp">
+) {
+  return setCachedQuery.run(cachedResponse);
+}
+
+export function createCacheKey(request: Request) {
+  return hasher.h64(
+    `${request.method} ${request.url} ${request.headers.get("Authorization")}`
+  );
+}
+
+export function createResponseFromCached(
+  cached: Omit<CachedResponse, "timestamp" | "key">
+) {
+  return new Response(cached.body, {
+    headers: {
+      "Content-Type": cached.contentType ?? "application/octet-stream",
+    },
+    status: cached.status,
+  });
+}

src/cache.ts

@@ -1,6 +1,6 @@
 import { handleApiRequest } from "./routes/api";
 
-Bun.serve({
+const server = Bun.serve({
   fetch(request) {
     const url = new URL(request.url);
 
@@ -10,5 +10,6 @@ Bun.serve({
 
     return new Response("Not found", { status: 404 });
   },
-  port: 3000,
 });
+
+console.log(`Listening on :${server.port}`);

src/index.ts

@@ -1,9 +1,11 @@
-import { cache, createCacheKey } from "../utils";
+import {
+  createCacheKey,
+  createResponseFromCached,
+  getCachedResponse,
+  setCachedResponse,
+} from "../cache";
 
-interface CachedResponse {
-  headers: [string, string][];
-  body: string | null;
-}
+const requestMap = new Map<bigint, Promise<Response>>();
 
 export async function handleApiRequest(request: Request, url: URL) {
   url.hostname = "discord.com";
@@ -12,7 +14,7 @@ export async function handleApiRequest(request: Request, url: URL) {
 
   request.headers.set("Host", "discord.com");
 
-  if (request.method !== "GET") {
+  if (request.method !== "GET" && request.method !== "HEAD") {
     return fetch(url.toString(), {
       method: request.method,
       headers: request.headers,
@@ -22,28 +24,47 @@ export async function handleApiRequest(request: Request, url: URL) {
 
   const cacheKey = createCacheKey(request);
 
-  const existing = (await cache.get(cacheKey)) as CachedResponse | undefined;
+  const existingCache = getCachedResponse(cacheKey);
 
-  if (existing) {
-    return new Response(existing.body, {
-      headers: new Headers(existing.headers),
-    });
+  if (existingCache) {
+    return createResponseFromCached(existingCache);
+  }
+
+  const existingRequest = requestMap.get(cacheKey);
+
+  if (existingRequest) {
+    return existingRequest;
   }
 
+  const promise = makeRequest(cacheKey, url, request).finally(() => {
+    requestMap.delete(cacheKey);
+  });
+
+  requestMap.set(cacheKey, promise);
+
+  return promise;
+}
+
+async function makeRequest(cacheKey: bigint, url: URL, request: Request) {
   const response = await fetch(url.toString(), {
     method: request.method,
     headers: request.headers,
     body: request.body,
   });
 
-  const content = response.status === 204 ? null : await response.text();
+  const content =
+    response.status === 204
+      ? undefined
+      : new Uint8Array(await response.arrayBuffer());
 
-  await cache.set(cacheKey, {
-    headers: [...response.headers.entries()],
+  const cachedResponse = {
+    key: cacheKey,
     body: content,
-  } satisfies CachedResponse);
+    contentType: response.headers.get("Content-Type") ?? undefined,
+    status: response.status,
+  };
 
-  return new Response(content, {
-    headers: response.headers,
-  });
+  setCachedResponse(cachedResponse);
+
+  return createResponseFromCached(cachedResponse);
 }