gitforest 0.1.0 → 1.0.0

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

@@ -1,1028 +0,0 @@
-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();
-    });
-  });
-});