remove follows cache, fetch fresh each time

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/db.zig

···
 // static buffer for db path (env vars return slices, zqlite needs sentinel)
 var db_path_buf: [256]u8 = undefined;
 
-// follows cache TTL: 5 minutes
-const FOLLOWS_CACHE_TTL_MS: i64 = 5 * 60 * 1000;
 
 pub fn init() !void {
     const db_path_env = posix.getenv("DATABASE_PATH") orelse "/data/feed.db";
···
     return rest[0..end];
 }
 
-/// get follows set for a DID, using cache if fresh
+/// get follows set for a DID
 fn getFollowsSet(alloc: std.mem.Allocator, requester_did: []const u8) !std.StringHashMap(void) {
     var set = std.StringHashMap(void).init(alloc);
     errdefer set.deinit();
 
-    const now = std.time.milliTimestamp();
-
-    // check cache freshness
-    mutex.lock();
-    const conn = db orelse {
-        mutex.unlock();
-        return error.NotInitialized;
-    };
-
-    var cache_fresh = false;
-    var cache_rows = conn.rows(
-        "SELECT cached_at FROM follows_cache WHERE requester_did = ? LIMIT 1",
-        .{requester_did},
-    ) catch {
-        mutex.unlock();
-        return set;
-    };
-
-    if (cache_rows.next()) |row| {
-        const cached_at = row.int(0);
-        if (now - cached_at < FOLLOWS_CACHE_TTL_MS) {
-            cache_fresh = true;
-        }
-    }
-    cache_rows.deinit();
-
-    if (cache_fresh) {
-        // load from cache
-        var follows_rows = conn.rows(
-            "SELECT follows_did FROM follows_cache WHERE requester_did = ?",
-            .{requester_did},
-        ) catch {
-            mutex.unlock();
-            return set;
-        };
-
-        while (follows_rows.next()) |row| {
-            const did = row.text(0);
-            const owned = try alloc.dupe(u8, did);
-            try set.put(owned, {});
-        }
-        follows_rows.deinit();
-        mutex.unlock();
-
-        std.debug.print("loaded {d} follows from cache for {s}\n", .{ set.count(), requester_did });
-        return set;
-    }
-    mutex.unlock();
-
-    // fetch fresh follows from API
     std.debug.print("fetching follows for {s}...\n", .{requester_did});
     const follows = atproto.getFollows(alloc, requester_did) catch |err| {
         std.debug.print("failed to fetch follows: {}\n", .{err});
···
     };
     defer alloc.free(follows);
 
-    // parse follows and populate set
     var it = std.mem.splitScalar(u8, follows, '\n');
     while (it.next()) |did| {
         if (did.len == 0) continue;
···
 
     std.debug.print("fetched {d} follows for {s}\n", .{ set.count(), requester_did });
 
-    // trigger lazy backfill for follows we haven't seen before
+    // trigger backfill for follows we haven't seen before
     var dids_to_backfill: std.ArrayList([]const u8) = .empty;
     defer dids_to_backfill.deinit(alloc);
     var key_it = set.keyIterator();
···
     }
     if (dids_to_backfill.items.len > 0) {
         triggerBackfill(alloc, dids_to_backfill.items);
-    }
-
-    // update cache
-    mutex.lock();
-    defer mutex.unlock();
-
-    // clear old cache for this user
-    conn.exec("DELETE FROM follows_cache WHERE requester_did = ?", .{requester_did}) catch {};
-
-    // insert new follows
-    var set_it = set.keyIterator();
-    while (set_it.next()) |key| {
-        conn.exec(
-            "INSERT INTO follows_cache (requester_did, follows_did, cached_at) VALUES (?, ?, ?)",
-            .{ requester_did, key.*, now },
-        ) catch {};
     }
 
     return set;