gitforest 0.1.0

package/test/unit/github/cache.test.ts

@@ -0,0 +1,1028 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { fetchGitHubReposWithCache } from "../../../src/github/cache.ts";
+import type { GitHubRepoInfo } from "../../../src/types/index.ts";
+import type { GitHubService } from "../../../src/services/github.ts";
+import type { DbInstance } from "../../../src/db/index.ts";
+
+const sampleRepo = {
+  id: 1,
+  name: "demo",
+  fullName: "owner/demo",
+  description: null,
+  htmlUrl: "",
+  sshUrl: "",
+  cloneUrl: "",
+  isPrivate: false,
+  isArchived: false,
+  isFork: false,
+  createdAt: "",
+  updatedAt: "",
+  pushedAt: "",
+  size: 0,
+  stargazersCount: 0,
+  forksCount: 0,
+  openIssuesCount: 0,
+  watchersCount: 0,
+  topics: [] as string[],
+  license: null as { name: string } | null,
+  hasIssues: true,
+  hasWiki: true,
+  hasDiscussions: false,
+  language: null as string | null,
+  defaultBranch: "main",
+  owner: { login: "owner", type: "User" as const },
+};
+
+const toInfo = (data: typeof sampleRepo): GitHubRepoInfo => ({
+  name: data.name,
+  fullName: data.fullName,
+  owner: data.owner.login,
+  description: data.description,
+  htmlUrl: data.htmlUrl,
+  sshUrl: data.sshUrl,
+  cloneUrl: data.cloneUrl,
+  isPrivate: data.isPrivate,
+  isArchived: data.isArchived,
+  isFork: data.isFork,
+  pushedAt: null,
+  updatedAt: null,
+  defaultBranch: data.defaultBranch,
+  language: data.language,
+  size: data.size,
+  stargazersCount: data.stargazersCount,
+  forksCount: data.forksCount,
+  openIssuesCount: data.openIssuesCount,
+  watchersCount: data.watchersCount,
+  topics: data.topics,
+  license: data.license?.name ?? null,
+  hasIssues: data.hasIssues,
+  hasWiki: data.hasWiki,
+  hasDiscussions: data.hasDiscussions,
+});
+
+const makeDbStub = (): DbInstance =>
+  ({
+    delete: () => ({ run: async () => {} }),
+    insert: () => ({ values: async () => {} }),
+    select: () => ({ from: () => ({ all: async () => [] }) }),
+  } as unknown as DbInstance);
+
+describe("fetchGitHubReposWithCache token fallback", () => {
+  const originalGithubToken = process.env.GITHUB_TOKEN;
+  const originalGhToken = process.env.GH_TOKEN;
+
+  beforeEach(() => {
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.GH_TOKEN;
+  });
+
+  afterEach(() => {
+    if (originalGithubToken !== undefined) {
+      process.env.GITHUB_TOKEN = originalGithubToken;
+    } else {
+      delete process.env.GITHUB_TOKEN;
+    }
+    if (originalGhToken !== undefined) {
+      process.env.GH_TOKEN = originalGhToken;
+    } else {
+      delete process.env.GH_TOKEN;
+    }
+  });
+
+  test("uses gh CLI token when env vars are missing", async () => {
+    let tokenProviderCalled = false;
+    const tokenProvider = async () => {
+      tokenProviderCalled = true;
+      process.env.GITHUB_TOKEN = "gh-from-cli";
+      return process.env.GITHUB_TOKEN;
+    };
+
+    const githubService: GitHubService = {
+      hasToken: () => !!process.env.GITHUB_TOKEN,
+      getToken: () => process.env.GITHUB_TOKEN ?? null,
+      // Methods below are unused in this test
+      getAuthenticatedUser: async () => {
+        throw new Error("not implemented");
+      },
+      getUserOrgs: async () => [],
+      getUserRepos: async () => [],
+      getOrgRepos: async () => [],
+      getAllRepos: async () => [sampleRepo],
+      getRepo: async () => {
+        throw new Error("not implemented");
+      },
+      searchRepos: async () => [],
+      createRepo: async () => ({ success: false }),
+      archiveRepo: async () => ({ success: false }),
+      unarchiveRepo: async () => ({ success: false }),
+      deleteRepo: async () => ({ success: false }),
+      cloneRepo: async () => ({ success: false, operation: "clone", projectPath: "" }),
+    };
+
+    const result = await fetchGitHubReposWithCache(
+      {},
+      0,
+      {
+        githubService,
+        toGitHubRepoInfo: toInfo,
+        db: makeDbStub(),
+        tokenProvider,
+      }
+    );
+
+    expect(tokenProviderCalled).toBe(true);
+    expect(result.repos).toHaveLength(1);
+    expect(result.repos[0]?.name).toBe("demo");
+    expect(result.fromCache).toBe(false);
+  });
+
+  test("does not call gh CLI when env token exists", async () => {
+    process.env.GITHUB_TOKEN = "env-token";
+    let tokenProviderCalled = false;
+    const tokenProvider = async () => {
+      tokenProviderCalled = true;
+      return "gh-from-cli";
+    };
+
+    const githubService: GitHubService = {
+      hasToken: () => !!process.env.GITHUB_TOKEN,
+      getToken: () => process.env.GITHUB_TOKEN ?? null,
+      getAuthenticatedUser: async () => {
+        throw new Error("not implemented");
+      },
+      getUserOrgs: async () => [],
+      getUserRepos: async () => [],
+      getOrgRepos: async () => [],
+      getAllRepos: async () => [sampleRepo],
+      getRepo: async () => {
+        throw new Error("not implemented");
+      },
+      searchRepos: async () => [],
+      createRepo: async () => ({ success: false }),
+      archiveRepo: async () => ({ success: false }),
+      unarchiveRepo: async () => ({ success: false }),
+      deleteRepo: async () => ({ success: false }),
+      cloneRepo: async () => ({ success: false, operation: "clone", projectPath: "" }),
+    };
+
+    const result = await fetchGitHubReposWithCache(
+      {},
+      0,
+      {
+        githubService,
+        toGitHubRepoInfo: toInfo,
+        db: makeDbStub(),
+        tokenProvider,
+      }
+    );
+
+    expect(tokenProviderCalled).toBe(false);
+    expect(result.repos).toHaveLength(1);
+    expect(result.repos[0]?.name).toBe("demo");
+  });
+});
+
+/**
+ * Tests for GitHub cache module
+ *
+ * Uses dependency injection instead of mock.module() for better test isolation
+ */
+
+import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import * as schema from "../../../src/db/schema.ts";
+import {
+  saveGitHubReposToCache,
+  loadGitHubReposFromCache,
+  fetchGitHubReposWithCache,
+  clearGitHubCache,
+  type CacheDeps
+} from "../../../src/github/cache.ts";
+import type { GitHubRepoInfo } from "../../../src/types/index.ts";
+import type { DbInstance } from "../../../src/db/index.ts";
+import type { GitHubService } from "../../../src/services/github.ts";
+import { createMockGitHubRepoInfo } from "../mocks/unified.ts";
+
+// Helper function to create multiple mock repos
+function createMockRepos(count: number, prefix = "repo"): GitHubRepoInfo[] {
+  return Array.from({ length: count }, (_, i) =>
+    createMockGitHubRepoInfo({
+      name: `${prefix}-${i + 1}`,
+      fullName: `user/${prefix}-${i + 1}`,
+    })
+  );
+}
+
+/**
+ * Create an in-memory database for testing
+ */
+function createTestDb(): { db: DbInstance; sqliteDb: Database } {
+  const sqliteDb = new Database(":memory:");
+  sqliteDb.run("PRAGMA foreign_keys = ON");
+
+  // Create github_repos table
+  sqliteDb.run(`
+    CREATE TABLE IF NOT EXISTS github_repos (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      full_name TEXT NOT NULL UNIQUE,
+      owner TEXT NOT NULL,
+      description TEXT,
+      html_url TEXT,
+      ssh_url TEXT,
+      clone_url TEXT,
+      is_private INTEGER,
+      is_archived INTEGER,
+      is_fork INTEGER,
+      pushed_at INTEGER,
+      updated_at INTEGER,
+      default_branch TEXT,
+      language TEXT,
+      size INTEGER,
+      stargazers_count INTEGER,
+      forks_count INTEGER,
+      open_issues_count INTEGER,
+      watchers_count INTEGER,
+      topics TEXT,
+      license TEXT,
+      has_issues INTEGER,
+      has_wiki INTEGER,
+      has_discussions INTEGER,
+      last_fetched INTEGER
+    );
+  `);
+
+  const db = drizzle(sqliteDb, { schema });
+  return { db, sqliteDb };
+}
+
+/**
+ * Create a mock GitHub service for testing
+ */
+function createMockGitHubService(overrides?: Partial<GitHubService>): GitHubService {
+  return {
+    hasToken: mock(() => true),
+    getToken: mock(() => "mock-token"),
+    getAuthenticatedUser: mock(() => Promise.resolve({ login: "testuser", id: 1, type: "User" as const })),
+    getUserOrgs: mock(() => Promise.resolve([])),
+    getUserRepos: mock(() => Promise.resolve([])),
+    getOrgRepos: mock(() => Promise.resolve([])),
+    getAllRepos: mock(() => Promise.resolve([])),
+    getRepo: mock(() => Promise.resolve({} as any)),
+    searchRepos: mock(() => Promise.resolve([])),
+    createRepo: mock(() => Promise.resolve({ success: true })),
+    archiveRepo: mock(() => Promise.resolve({ success: true })),
+    unarchiveRepo: mock(() => Promise.resolve({ success: true })),
+    deleteRepo: mock(() => Promise.resolve({ success: true })),
+    cloneRepo: mock(() => Promise.resolve({ success: true, projectPath: "", operation: "clone" as const })),
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock toGitHubRepoInfo function for testing
+ */
+function createMockToGitHubRepoInfo(): (data: any) => GitHubRepoInfo {
+  return (data: any) => ({
+    name: data.name,
+    fullName: data.fullName,
+    owner: data.owner?.login || data.owner,
+    description: data.description,
+    htmlUrl: data.html_url || data.htmlUrl || "",
+    sshUrl: data.ssh_url || data.sshUrl || "",
+    cloneUrl: data.clone_url || data.cloneUrl || "",
+    isPrivate: data.is_private !== undefined ? Boolean(data.is_private) : Boolean(data.isPrivate),
+    isArchived: data.is_archived !== undefined ? Boolean(data.is_archived) : Boolean(data.isArchived),
+    isFork: data.is_fork !== undefined ? Boolean(data.is_fork) : Boolean(data.isFork),
+    pushedAt: data.pushed_at ? new Date(data.pushed_at) : data.pushedAt ? new Date(data.pushedAt) : null,
+    updatedAt: data.updated_at ? new Date(data.updated_at) : data.updatedAt ? new Date(data.updatedAt) : null,
+    defaultBranch: data.default_branch || data.defaultBranch || "main",
+    language: data.language,
+    size: data.size || 0,
+    stargazersCount: data.stargazers_count || data.stargazersCount || 0,
+    forksCount: data.forks_count || data.forksCount || 0,
+    openIssuesCount: data.open_issues_count || data.openIssuesCount || 0,
+    watchersCount: data.watchers_count || data.watchersCount || 0,
+    topics: data.topics || [],
+    license: data.license?.name || data.license || null,
+    hasIssues: data.has_issues !== undefined ? Boolean(data.has_issues) : Boolean(data.hasIssues),
+    hasWiki: data.has_wiki !== undefined ? Boolean(data.has_wiki) : Boolean(data.hasWiki),
+    hasDiscussions: data.has_discussions !== undefined ? Boolean(data.has_discussions) : Boolean(data.hasDiscussions),
+  });
+}
+
+describe("GitHub Cache", () => {
+  let sqliteDb: Database;
+  let db: DbInstance;
+
+  beforeEach(() => {
+    const testDb = createTestDb();
+    db = testDb.db;
+    sqliteDb = testDb.sqliteDb;
+  });
+
+  afterEach(() => {
+    sqliteDb.close();
+  });
+
+  describe("saveGitHubReposToCache", () => {
+    test("saves repos to cache successfully", async () => {
+      const repos = [
+        createMockGitHubRepoInfo({
+          name: "repo1",
+          fullName: "user/repo1",
+          topics: ["typescript", "react"]
+        }),
+        createMockGitHubRepoInfo({
+          name: "repo2",
+          fullName: "user/repo2",
+          topics: ["javascript", "node"]
+        }),
+      ];
+
+      await saveGitHubReposToCache(repos, { db });
+
+      const cached = db.select().from(schema.githubRepos).all();
+      expect(cached).toHaveLength(2);
+      expect(cached[0]?.name).toBe("repo1");
+      expect(cached[0]?.fullName).toBe("user/repo1");
+      expect(cached[0]?.topics).toBe(JSON.stringify(["typescript", "react"]));
+      expect(cached[1]?.name).toBe("repo2");
+      expect(cached[1]?.fullName).toBe("user/repo2");
+      expect(cached[1]?.topics).toBe(JSON.stringify(["javascript", "node"]));
+    });
+
+    test("clears existing cache before saving", async () => {
+      // Insert initial data
+      db.insert(schema.githubRepos).values({
+        name: "old-repo",
+        fullName: "user/old-repo",
+        owner: "user",
+        lastFetched: new Date(Date.now() - 86400000), // 1 day ago
+      }).run();
+
+      expect(db.select().from(schema.githubRepos).all()).toHaveLength(1);
+
+      // Save new repos
+      const repos = [createMockGitHubRepoInfo({ name: "new-repo" })];
+      await saveGitHubReposToCache(repos, { db });
+
+      const cached = db.select().from(schema.githubRepos).all();
+      expect(cached).toHaveLength(1);
+      expect(cached[0]?.name).toBe("new-repo");
+    });
+
+    test("handles empty repos array", async () => {
+      await saveGitHubReposToCache([], { db });
+
+      const cached = db.select().from(schema.githubRepos).all();
+      expect(cached).toHaveLength(0);
+    });
+
+    test("handles null/undefined fields gracefully", async () => {
+      const repos: GitHubRepoInfo[] = [{
+        name: "test-repo",
+        fullName: "user/test-repo",
+        owner: "user",
+        description: null,
+        htmlUrl: "",
+        sshUrl: "",
+        cloneUrl: "",
+        isPrivate: false,
+        isArchived: false,
+        isFork: false,
+        pushedAt: null,
+        updatedAt: null,
+        defaultBranch: "main",
+        language: null,
+        size: 0,
+        stargazersCount: 0,
+        forksCount: 0,
+        openIssuesCount: 0,
+        watchersCount: 0,
+        topics: undefined,
+        license: null,
+        hasIssues: false,
+        hasWiki: false,
+        hasDiscussions: false,
+      }];
+
+      await saveGitHubReposToCache(repos, { db });
+
+      const cached = db.select().from(schema.githubRepos).all();
+      expect(cached).toHaveLength(1);
+      expect(cached[0]?.topics).toBeNull();
+    });
+
+    test("handles database errors gracefully", async () => {
+      const repos = [createMockGitHubRepoInfo()];
+
+      // Should complete without throwing
+      await expect(saveGitHubReposToCache(repos, { db })).resolves.toBeUndefined();
+    });
+  });
+
+  describe("loadGitHubReposFromCache", () => {
+    test("loads repos from cache successfully", async () => {
+      // Insert test data
+      const now = new Date();
+      db.insert(schema.githubRepos).values([
+        {
+          name: "cached-repo1",
+          fullName: "user/cached-repo1",
+          owner: "user",
+          description: "Test repo 1",
+          htmlUrl: "https://github.com/user/cached-repo1",
+          sshUrl: "git@github.com:user/cached-repo1.git",
+          cloneUrl: "https://github.com/user/cached-repo1.git",
+          isPrivate: false,
+          isArchived: false,
+          isFork: false,
+          pushedAt: now,
+          updatedAt: now,
+          defaultBranch: "main",
+          language: "TypeScript",
+          size: 1024,
+          stargazersCount: 100,
+          forksCount: 20,
+          openIssuesCount: 5,
+          watchersCount: 50,
+          topics: JSON.stringify(["typescript", "react"]),
+          license: "MIT",
+          hasIssues: true,
+          hasWiki: true,
+          hasDiscussions: false,
+          lastFetched: now,
+        },
+        {
+          name: "cached-repo2",
+          fullName: "user/cached-repo2",
+          owner: "user",
+          description: "Test repo 2",
+          lastFetched: now,
+        }
+      ]).run();
+
+      const repos = await loadGitHubReposFromCache({ db });
+
+      expect(repos).toHaveLength(2);
+      expect(repos[0]?.name).toBe("cached-repo1");
+      expect(repos[0]?.fullName).toBe("user/cached-repo1");
+      expect(repos[0]?.topics).toEqual(["typescript", "react"]);
+      expect(repos[1]?.name).toBe("cached-repo2");
+    });
+
+    test("handles empty cache", async () => {
+      const repos = await loadGitHubReposFromCache({ db });
+      expect(repos).toEqual([]);
+    });
+
+    test("JSON parsing of topics field", async () => {
+      db.insert(schema.githubRepos).values({
+        name: "topic-repo",
+        fullName: "user/topic-repo",
+        owner: "user",
+        topics: JSON.stringify(["javascript", "node", "express"]),
+        lastFetched: new Date(),
+      }).run();
+
+      const repos = await loadGitHubReposFromCache({ db });
+      expect(repos[0]?.topics).toEqual(["javascript", "node", "express"]);
+    });
+
+    test("handles invalid JSON in topics field", async () => {
+      db.insert(schema.githubRepos).values({
+        name: "invalid-topic-repo",
+        fullName: "user/invalid-topic-repo",
+        owner: "user",
+        topics: "invalid-json",
+        lastFetched: new Date(),
+      }).run();
+
+      const repos = await loadGitHubReposFromCache({ db });
+      expect(repos[0]?.topics).toEqual([]);
+    });
+
+    test("handles null/undefined database fields", async () => {
+      db.insert(schema.githubRepos).values({
+        name: "null-fields-repo",
+        fullName: "user/null-fields-repo",
+        owner: "user",
+        htmlUrl: null,
+        sshUrl: undefined,
+        isPrivate: null,
+        isArchived: null,
+        isFork: null,
+        defaultBranch: null,
+        size: null,
+        stargazersCount: null,
+        forksCount: null,
+        openIssuesCount: null,
+        watchersCount: null,
+        topics: null,
+        license: null,
+        hasIssues: null,
+        hasWiki: null,
+        hasDiscussions: null,
+        lastFetched: new Date(),
+      }).run();
+
+      const repos = await loadGitHubReposFromCache({ db });
+      const repo = repos[0];
+
+      expect(repo?.htmlUrl).toBe("");
+      expect(repo?.sshUrl).toBe("");
+      expect(repo?.isPrivate).toBe(false);
+      expect(repo?.isArchived).toBe(false);
+      expect(repo?.isFork).toBe(false);
+      expect(repo?.defaultBranch).toBe("main");
+      expect(repo?.size).toBe(0);
+      expect(repo?.stargazersCount).toBe(0);
+      expect(repo?.forksCount).toBe(0);
+      expect(repo?.openIssuesCount).toBe(0);
+      expect(repo?.watchersCount).toBe(0);
+      expect(repo?.topics).toEqual([]);
+      expect(repo?.license).toBeNull();
+      expect(repo?.hasIssues).toBe(false);
+      expect(repo?.hasWiki).toBe(false);
+      expect(repo?.hasDiscussions).toBe(false);
+    });
+  });
+
+  describe("fetchGitHubReposWithCache", () => {
+    test("returns cached data when cache is fresh", async () => {
+      const now = new Date();
+      const cachedRepo = {
+        name: "fresh-cache-repo",
+        fullName: "user/fresh-cache-repo",
+        owner: "user",
+        lastFetched: now,
+        updatedAt: now,
+      };
+
+      db.insert(schema.githubRepos).values(cachedRepo).run();
+
+      const mockService = createMockGitHubService();
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toHaveLength(1);
+      expect(result.fromCache).toBe(true);
+      expect(result.repos[0]?.name).toBe("fresh-cache-repo");
+      expect(mockService.getAllRepos).not.toHaveBeenCalled();
+    });
+
+    test("fetches fresh data when cache is stale", async () => {
+      // Insert stale cache data (10 minutes ago)
+      const oldDate = new Date(Date.now() - 600000);
+      db.insert(schema.githubRepos).values({
+        name: "stale-cache-repo",
+        fullName: "user/stale-cache-repo",
+        owner: "user",
+        lastFetched: oldDate,
+        updatedAt: oldDate,
+      }).run();
+
+      // Mock getAllRepos to return empty array (simulating no new repos)
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.resolve([])),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      // Since cache is stale, it should fetch fresh data
+      expect(result.fromCache).toBe(false);
+      expect(mockService.getAllRepos).toHaveBeenCalled();
+    });
+
+    test("returns error when no token", async () => {
+      const mockService = createMockGitHubService({
+        hasToken: mock(() => false),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toEqual([]);
+      expect(result.fromCache).toBe(false);
+      expect(result.error).toBe("GITHUB_TOKEN not set");
+      expect(mockService.getAllRepos).not.toHaveBeenCalled();
+    });
+
+    test("fallback to stale cache on fetch error", async () => {
+      // Insert stale cache data
+      const staleDate = new Date(Date.now() - 600000); // 10 minutes ago
+      db.insert(schema.githubRepos).values({
+        name: "stale-cache-repo",
+        fullName: "user/stale-cache-repo",
+        owner: "user",
+        lastFetched: staleDate,
+        updatedAt: staleDate,
+      }).run();
+
+      // Mock fetch error
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.reject(new Error("API Error"))),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toHaveLength(1);
+      expect(result.fromCache).toBe(true);
+      expect(result.error).toBe("API Error");
+      expect(result.repos[0]?.name).toBe("stale-cache-repo");
+    });
+
+    test("returns empty array when fetch fails and no cache available", async () => {
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.reject(new Error("Network Error"))),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toEqual([]);
+      expect(result.fromCache).toBe(false);
+      expect(result.error).toBe("Network Error");
+    });
+
+    test("respects custom cache TTL", async () => {
+      // Insert data that's 2 minutes old (120 seconds)
+      const twoMinutesAgo = new Date(Date.now() - 120000);
+      db.insert(schema.githubRepos).values({
+        name: "ttl-test-repo",
+        fullName: "user/ttl-test-repo",
+        owner: "user",
+        lastFetched: twoMinutesAgo,
+        updatedAt: twoMinutesAgo,
+      }).run();
+
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.resolve([])),
+      });
+
+      // With TTL of 300 seconds (5 minutes), cache should be fresh
+      let result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+      expect(result.fromCache).toBe(true);
+
+      // Reset mock call count
+      (mockService.getAllRepos as any).mockClear();
+
+      // With TTL of 60 seconds (1 minute), cache should be stale
+      result = await fetchGitHubReposWithCache({}, 60, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+      expect(result.fromCache).toBe(false);
+    });
+
+    test("passes options to getAllRepos", async () => {
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.resolve([])),
+      });
+
+      const options = {
+        includeOrgs: true,
+        includeArchived: false,
+        includeForks: true,
+      };
+
+      await fetchGitHubReposWithCache(options, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(mockService.getAllRepos).toHaveBeenCalledWith(options);
+    });
+  });
+
+  describe("Cache freshness check", () => {
+    test("correctly identifies fresh cache", async () => {
+      // Insert fresh data (1 minute ago)
+      const oneMinuteAgo = new Date(Date.now() - 60000);
+      db.insert(schema.githubRepos).values({
+        name: "fresh-repo",
+        fullName: "user/fresh-repo",
+        owner: "user",
+        lastFetched: oneMinuteAgo,
+        updatedAt: oneMinuteAgo,
+      }).run();
+
+      const mockService = createMockGitHubService();
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      }); // 5 minute TTL
+
+      expect(result.fromCache).toBe(true);
+    });
+
+    test("correctly identifies stale cache", async () => {
+      // Insert stale data (10 minutes ago)
+      const tenMinutesAgo = new Date(Date.now() - 600000);
+      db.insert(schema.githubRepos).values({
+        name: "stale-repo",
+        fullName: "user/stale-repo",
+        owner: "user",
+        lastFetched: tenMinutesAgo,
+        updatedAt: tenMinutesAgo,
+      }).run();
+
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.resolve([])),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      }); // 5 minute TTL
+
+      expect(result.fromCache).toBe(false);
+    });
+
+    test("handles null updatedAt as stale", async () => {
+      // Insert data with null updatedAt
+      db.insert(schema.githubRepos).values({
+        name: "null-date-repo",
+        fullName: "user/null-date-repo",
+        owner: "user",
+        lastFetched: new Date(),
+        updatedAt: null,
+      }).run();
+
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.resolve([])),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.fromCache).toBe(false);
+    });
+  });
+
+  describe("Additional fetchGitHubReposWithCache tests", () => {
+    test("returns cached data when fresh (within TTL)", async () => {
+      // Insert fresh cache data
+      const now = new Date();
+      db.insert(schema.githubRepos).values({
+        name: "fresh-cache-repo",
+        fullName: "user/fresh-cache-repo",
+        owner: "user",
+        lastFetched: now,
+        updatedAt: now,
+      }).run();
+
+      const mockService = createMockGitHubService();
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toHaveLength(1);
+      expect(result.fromCache).toBe(true);
+      expect(result.repos[0]?.name).toBe("fresh-cache-repo");
+      expect(mockService.getAllRepos).not.toHaveBeenCalled();
+    });
+
+    test("fetches fresh data when TTL is 0", async () => {
+      // Insert cache data
+      db.insert(schema.githubRepos).values({
+        name: "cache-repo",
+        fullName: "user/cache-repo",
+        owner: "user",
+        lastFetched: new Date(),
+        updatedAt: new Date(),
+      }).run();
+
+      // Mock getAllRepos to return new repos
+      const newRepos = createMockRepos(1, "fresh-repo");
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.resolve(newRepos as any)),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 0, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.fromCache).toBe(false);
+      expect(result.repos).toHaveLength(1);
+      expect(result.repos[0]?.name).toBe("fresh-repo-1");
+      expect(mockService.getAllRepos).toHaveBeenCalled();
+    });
+
+    test("saves fetched data to cache", async () => {
+      // Mock getAllRepos to return repos
+      const newRepos = createMockRepos(3, "saved-repo");
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.resolve(newRepos as any)),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.fromCache).toBe(false);
+      expect(result.repos).toHaveLength(3);
+
+      // Wait a bit for background save to complete
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Verify cache was updated
+      const cached = await loadGitHubReposFromCache({ db });
+      expect(cached).toHaveLength(3);
+      expect(cached[0]?.name).toBe("saved-repo-1");
+    });
+
+    test("returns error message when GitHub token not set", async () => {
+      const mockService = createMockGitHubService({
+        hasToken: mock(() => false),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toEqual([]);
+      expect(result.fromCache).toBe(false);
+      expect(result.error).toBe("GITHUB_TOKEN not set");
+      expect(mockService.getAllRepos).not.toHaveBeenCalled();
+    });
+
+    test("handles API errors gracefully", async () => {
+      // Mock API error
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.reject(new Error("API Rate Limit Exceeded"))),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toEqual([]);
+      expect(result.fromCache).toBe(false);
+      expect(result.error).toBe("API Rate Limit Exceeded");
+    });
+
+    test("returns cached data on API failure if available", async () => {
+      // Insert stale cache data
+      const staleDate = new Date(Date.now() - 600000); // 10 minutes ago
+      db.insert(schema.githubRepos).values({
+        name: "stale-cache-repo",
+        fullName: "user/stale-cache-repo",
+        owner: "user",
+        lastFetched: staleDate,
+        updatedAt: staleDate,
+      }).run();
+
+      // Mock API error
+      const mockService = createMockGitHubService({
+        getAllRepos: mock(() => Promise.reject(new Error("Network Error"))),
+      });
+
+      const result = await fetchGitHubReposWithCache({}, 300, {
+        db,
+        githubService: mockService,
+        toGitHubRepoInfo: createMockToGitHubRepoInfo(),
+      });
+
+      expect(result.repos).toHaveLength(1);
+      expect(result.fromCache).toBe(true);
+      expect(result.error).toBe("Network Error");
+      expect(result.repos[0]?.name).toBe("stale-cache-repo");
+    });
+  });
+
+  describe("Additional loadGitHubReposFromCache tests", () => {
+    test("returns empty array when no cache", async () => {
+      const repos = await loadGitHubReposFromCache({ db });
+      expect(repos).toEqual([]);
+    });
+
+    test("returns cached repos when available", async () => {
+      const now = new Date();
+      db.insert(schema.githubRepos).values([
+        {
+          name: "repo1",
+          fullName: "user/repo1",
+          owner: "user",
+          lastFetched: now,
+        },
+        {
+          name: "repo2",
+          fullName: "user/repo2",
+          owner: "user",
+          lastFetched: now,
+        }
+      ]).run();
+
+      const repos = await loadGitHubReposFromCache({ db });
+
+      expect(repos).toHaveLength(2);
+      expect(repos[0]?.name).toBe("repo1");
+      expect(repos[1]?.name).toBe("repo2");
+    });
+
+    test("handles corrupted cache data", async () => {
+      // Insert data with corrupted topics JSON
+      db.insert(schema.githubRepos).values({
+        name: "corrupted-repo",
+        fullName: "user/corrupted-repo",
+        owner: "user",
+        topics: "{invalid json",
+        lastFetched: new Date(),
+      }).run();
+
+      // Should not throw and return empty topics array
+      const repos = await loadGitHubReposFromCache({ db });
+      expect(repos).toHaveLength(1);
+      expect(repos[0]?.topics).toEqual([]);
+    });
+  });
+
+  describe("Additional saveGitHubReposToCache tests", () => {
+    test("saves repos to database", async () => {
+      const repos = [
+        createMockGitHubRepoInfo({ name: "test-repo-1" }),
+        createMockGitHubRepoInfo({ name: "test-repo-2" }),
+      ];
+
+      await saveGitHubReposToCache(repos, { db });
+
+      const cached = db.select().from(schema.githubRepos).all();
+      expect(cached).toHaveLength(2);
+      expect(cached[0]?.name).toBe("test-repo-1");
+      expect(cached[1]?.name).toBe("test-repo-2");
+    });
+
+    test("updates existing cache entries", async () => {
+      // Insert initial data
+      db.insert(schema.githubRepos).values({
+        name: "old-repo",
+        fullName: "user/old-repo",
+        owner: "user",
+        description: "Old description",
+        lastFetched: new Date(Date.now() - 86400000), // 1 day ago
+      }).run();
+
+      const newRepos = [
+        createMockGitHubRepoInfo({
+          name: "new-repo",
+          description: "New description"
+        }),
+      ];
+
+      await saveGitHubReposToCache(newRepos, { db });
+
+      const cached = db.select().from(schema.githubRepos).all();
+      expect(cached).toHaveLength(1);
+      expect(cached[0]?.name).toBe("new-repo");
+      expect(cached[0]?.description).toBe("New description");
+    });
+
+    test("handles save failures gracefully", async () => {
+      const repos = [createMockGitHubRepoInfo()];
+
+      // Should complete without throwing
+      await expect(saveGitHubReposToCache(repos, { db })).resolves.toBeUndefined();
+    });
+  });
+});