feat: support worker cache by DurableObject

Co-Authored-By: Claude <81847+claude@users.noreply.github.com>

Author: zmh-program

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bytes-radar"
-version = "1.0.0"
+version = "1.1.0"
 edition = "2021"
 authors = ["ProgramZmh <zmh@lightxi.com>"]
 description = "A tool for analyzing code statistics from remote repositories with hyper-fast performance"

Cargo.toml

@@ -0,0 +1,118 @@
+interface CacheEntry {
+  data: any;
+  timestamp: number;
+  ttl: number;
+}
+
+export class CacheManager {
+  private cache: Map<string, CacheEntry>;
+  private readonly defaultTTL: number;
+  private readonly maxSize: number;
+  private readonly cleanupInterval: number;
+  private cleanupTimer: number | null;
+
+  constructor(
+    options: {
+      ttl?: number;
+      maxSize?: number;
+      cleanupInterval?: number;
+    } = {},
+  ) {
+    this.cache = new Map();
+    this.defaultTTL = options.ttl || 3600;
+    this.maxSize = options.maxSize || 1000;
+    this.cleanupInterval = options.cleanupInterval || 300;
+    this.cleanupTimer = null;
+    this.startCleanupTimer();
+  }
+
+  private startCleanupTimer(): void {
+    if (this.cleanupTimer) return;
+    this.cleanupTimer = setInterval(
+      () => this.cleanup(),
+      this.cleanupInterval * 1000,
+    ) as unknown as number;
+  }
+
+  private stopCleanupTimer(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  set(key: string, value: any, ttl: number = this.defaultTTL): void {
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = Array.from(this.cache.entries()).sort(
+        ([, a], [, b]) => a.timestamp - b.timestamp,
+      )[0][0];
+      this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, {
+      data: value,
+      timestamp: Date.now(),
+      ttl: ttl * 1000,
+    });
+  }
+
+  get(key: string): any | null {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+
+  has(key: string): boolean {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+
+  delete(key: string): void {
+    this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  cleanup(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > entry.ttl) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  getStats(): { total: number; expired: number; size: number } {
+    let total = 0;
+    let expired = 0;
+    const now = Date.now();
+
+    for (const entry of this.cache.values()) {
+      total++;
+      if (now - entry.timestamp > entry.ttl) {
+        expired++;
+      }
+    }
+
+    return { total, expired, size: this.cache.size };
+  }
+
+  destroy(): void {
+    this.stopCleanupTimer();
+    this.clear();
+  }
+}

worker/cache.ts

@@ -33,5 +33,22 @@ export interface AnalysisOptions {
   ignore_hidden: boolean;
   ignore_gitignore: boolean;
   aggressive_filtering?: boolean;
-  custom_filter?: IntelligentFilter;
+}
+
+export interface CacheOptions {
+  ttl?: number;
+  maxSize?: number;
+  cleanupInterval?: number;
+}
+
+export interface CacheStats {
+  total: number;
+  expired: number;
+  size: number;
+}
+
+export interface CacheEntry {
+  data: any;
+  timestamp: number;
+  ttl: number;
 }

worker/types.d.ts

@@ -1,5 +1,6 @@
 import type { AnalysisOptions } from "./types";
 import wasmBinary from "./pkg/bytes_radar_bg.wasm";
+import { CacheManager } from "./cache";
 
 export interface Env {
   BYTES_RADAR: DurableObjectNamespace;
@@ -8,66 +9,32 @@ export interface Env {
 }
 
 export class BytesRadar {
-  state: DurableObjectState;
-  env: Env;
-  private wasmModule: any = null;
-  private wasmInitialized = false;
-
-  constructor(state: DurableObjectState, env: Env) {
-    this.state = state;
-    this.env = env;
+  private wasmModule: any;
+  private wasmInitialized: boolean = false;
+  private cacheManager: CacheManager;
+
+  constructor() {
+    this.cacheManager = new CacheManager({
+      ttl: 7200,
+      maxSize: 5000,
+      cleanupInterval: 600,
+    });
   }
 
-  private log(
-    level: "debug" | "info" | "warn" | "error",
-    message: string,
-    data?: any,
-  ) {
-    const logLevel = this.env.LOG_LEVEL || "info";
-    const environment = this.env.ENVIRONMENT || "development";
-
-    const levels = { debug: 0, info: 1, warn: 2, error: 3 };
-    const currentLevel = levels[logLevel as keyof typeof levels] || 1;
-    const messageLevel = levels[level];
-
-    if (messageLevel >= currentLevel) {
-      const timestamp = new Date().toISOString();
-      const logEntry = {
-        timestamp,
-        level: level.toUpperCase(),
-        environment,
-        message,
-        ...(data && { data }),
-      };
-
-      const fn = {
-        debug: console.debug,
-        info: console.info,
-        warn: console.warn,
-        error: console.error,
-      };
-
-      if (environment === "production") {
-        fn[level](JSON.stringify(logEntry));
-      } else {
-        fn[level](`[${level.toUpperCase()}] ${message}`, data ? data : "");
-      }
-    }
+  private log(level: string, message: string, data?: any) {
+    console.log(JSON.stringify({ level, message, data }));
   }
 
   private async initializeWasm() {
-    if (!this.wasmInitialized) {
-      try {
-        this.wasmModule = await import("./pkg/bytes_radar");
-        await this.wasmModule.default(wasmBinary);
-        this.wasmInitialized = true;
-        this.log("info", "WebAssembly module initialized successfully");
-      } catch (error) {
-        this.log("error", "Failed to initialize WebAssembly module", {
-          error: error instanceof Error ? error.message : String(error),
-        });
-        throw error;
-      }
+    if (this.wasmInitialized) return;
+    try {
+      this.wasmModule = await import("./pkg/bytes_radar");
+      await this.wasmModule.default(wasmBinary);
+      this.wasmInitialized = true;
+      this.log("info", "WASM initialized");
+    } catch (error) {
+      this.log("error", "WASM init failed", error);
+      throw error;
     }
   }
 
@@ -82,7 +49,6 @@ export class BytesRadar {
       provider_settings: {},
     };
 
-    // Parse numeric options
     const numericOptions: Record<string, (val: number) => void> = {
       timeout: (val) => (options.timeout = val),
       max_redirects: (val) => (options.max_redirects = val),
@@ -99,7 +65,6 @@ export class BytesRadar {
       }
     }
 
-    // Parse string options
     const stringOptions: Record<string, (val: string) => void> = {
       user_agent: (val) => (options.user_agent = val),
       proxy: (val) => (options.proxy = val),
@@ -112,13 +77,11 @@ export class BytesRadar {
       }
     }
 
-    // Parse boolean options
     if (searchParams.get("aggressive_filtering") !== null) {
       options.aggressive_filtering =
         searchParams.get("aggressive_filtering") === "true";
     }
 
-    // Parse custom headers, credentials, and provider settings
     for (const [key, value] of searchParams.entries()) {
       if (key.startsWith("header.")) {
         options.headers[key.slice(7)] = value;
@@ -132,6 +95,11 @@ export class BytesRadar {
     return options;
   }
 
+  private generateCacheKey(url: string, options: AnalysisOptions): string {
+    const { headers, credentials, ...cacheableOptions } = options;
+    return `${url}:${JSON.stringify(cacheableOptions)}`;
+  }
+
   async fetch(request: Request) {
     const url = new URL(request.url);
     if (url.pathname === "/favicon.ico") {
@@ -149,14 +117,8 @@ export class BytesRadar {
       if (!targetUrl) {
         return new Response(
           JSON.stringify({
-            error: "Missing repository path",
-            usage: [
-              "/[user/repo",
-              "/user/repo@master",
-              "/github.com/user/repo",
-              "/gitlab.com/user/repo",
-              "http://example.com/example-asset.tar.gz",
-            ],
+            error: "Missing path",
+            usage: ["/user/repo", "/user/repo@branch", "/github.com/user/repo"],
           }),
           {
             status: 400,
@@ -169,20 +131,38 @@ export class BytesRadar {
       }
 
       const options = this.parseQueryOptions(url.searchParams);
-      this.log("info", "Starting analysis", { url: targetUrl, options });
+      const cacheKey = this.generateCacheKey(targetUrl, options);
+
+      const cachedResult = this.cacheManager.get(cacheKey);
+      if (cachedResult) {
+        this.log("info", "Cache hit", { url: targetUrl });
+        return new Response(JSON.stringify(cachedResult), {
+          headers: {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+            "X-Cache": "HIT",
+            "X-Cache-TTL": String(this.cacheManager["defaultTTL"]),
+          },
+        });
+      }
+
+      this.log("info", "Analysis start", { url: targetUrl });
 
       const result = await this.wasmModule.analyze_url(targetUrl, options);
-      this.log("info", "Analysis completed successfully", result);
+      this.cacheManager.set(cacheKey, result);
+
+      this.log("info", "Analysis done", result);
 
       return new Response(JSON.stringify(result), {
         headers: {
           "Content-Type": "application/json",
           "Access-Control-Allow-Origin": "*",
+          "X-Cache": "MISS",
         },
       });
     } catch (error: unknown) {
       const errorResponse = this.handleError(error, startTime);
-      this.log("error", "Error in BytesRadar fetch", errorResponse);
+      this.log("error", "Request failed", errorResponse);
 
       return new Response(JSON.stringify(errorResponse), {
         status: 500,