gitforest 0.1.0 → 1.1.0

package/test/unit/db/database.test.ts

@@ -1,978 +0,0 @@
-/**
- * Tests for database module
- * Uses in-memory SQLite for testing
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { drizzle } from "drizzle-orm/bun-sqlite";
-import { eq, sql } from "drizzle-orm";
-import * as schema from "../../../src/db/schema.ts";
-
-describe("Database", () => {
-  let sqliteDb: Database;
-  let db: ReturnType<typeof drizzle>;
-
-  beforeEach(() => {
-    // Use in-memory database for testing
-    sqliteDb = new Database(":memory:");
-    
-    // Enable foreign key constraints
-    sqliteDb.run("PRAGMA foreign_keys = ON");
-
-    // Create tables
-    sqliteDb.run(`
-      CREATE TABLE IF NOT EXISTS projects (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        path TEXT NOT NULL UNIQUE,
-        type TEXT NOT NULL,
-        project_marker TEXT,
-        status_json TEXT,
-        submodule_json TEXT,
-        last_scanned INTEGER
-      );
-
-      CREATE TABLE IF NOT EXISTS remote_status (
-        project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
-        last_fetched INTEGER,
-        unpulled_commits INTEGER,
-        remote_last_activity INTEGER,
-        remote_url TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS github_repos (
-        id INTEGER PRIMARY KEY,
-        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
-      );
-
-      CREATE TABLE IF NOT EXISTS config_cache (
-        key TEXT PRIMARY KEY,
-        value TEXT,
-        updated_at INTEGER
-      );
-    `);
-
-    db = drizzle(sqliteDb, { schema });
-  });
-
-  afterEach(() => {
-    sqliteDb.close();
-  });
-
-  describe("projects table", () => {
-    // Existing tests...
-    test("inserts a project", () => {
-      const project = {
-        id: "test-123",
-        name: "my-project",
-        path: "/home/user/my-project",
-        type: "git",
-        projectMarker: null,
-        statusJson: JSON.stringify({ isDirty: false }),
-        submoduleJson: null,
-        lastScanned: new Date(),
-      };
-
-      db.insert(schema.projects).values(project).run();
-
-      const result = db.select().from(schema.projects).all();
-      expect(result).toHaveLength(1);
-      expect(result[0]!.name).toBe("my-project");
-      expect(result[0]!.path).toBe("/home/user/my-project");
-    });
-
-    test("enforces unique path constraint", () => {
-      const project1 = {
-        id: "test-1",
-        name: "project-1",
-        path: "/home/user/project",
-        type: "git",
-      };
-
-      const project2 = {
-        id: "test-2",
-        name: "project-2",
-        path: "/home/user/project", // Same path
-        type: "git",
-      };
-
-      db.insert(schema.projects).values(project1).run();
-
-      // Should throw on duplicate path
-      expect(() => {
-        db.insert(schema.projects).values(project2).run();
-      }).toThrow();
-    });
-
-    test("updates a project", () => {
-      const project = {
-        id: "update-test",
-        name: "original-name",
-        path: "/home/user/project",
-        type: "git",
-      };
-
-      db.insert(schema.projects).values(project).run();
-
-      db.update(schema.projects)
-        .set({ name: "updated-name" })
-        .where(eq(schema.projects.id, "update-test"))
-        .run();
-
-      const result = db.select().from(schema.projects).where(eq(schema.projects.id, "update-test")).all();
-      expect(result[0]!.name).toBe("updated-name");
-    });
-
-    test("deletes a project", () => {
-      const project = {
-        id: "delete-test",
-        name: "to-delete",
-        path: "/home/user/to-delete",
-        type: "git",
-      };
-
-      db.insert(schema.projects).values(project).run();
-
-      // Verify it exists
-      let result = db.select().from(schema.projects).all();
-      expect(result).toHaveLength(1);
-
-      // Delete it
-      db.delete(schema.projects).where(eq(schema.projects.id, "delete-test")).run();
-
-      // Verify it's gone
-      result = db.select().from(schema.projects).all();
-      expect(result).toHaveLength(0);
-    });
-
-    test("stores different project types", () => {
-      const projects = [
-        { id: "git-1", name: "git-project", path: "/path/git", type: "git" },
-        { id: "sub-1", name: "submodule", path: "/path/sub", type: "git-submodule" },
-        { id: "non-1", name: "npm-project", path: "/path/npm", type: "non-git", projectMarker: "package.json" },
-      ];
-
-      for (const project of projects) {
-        db.insert(schema.projects).values(project).run();
-      }
-
-      const gitProjects = db.select().from(schema.projects).where(eq(schema.projects.type, "git")).all();
-      expect(gitProjects).toHaveLength(1);
-
-      const nonGitProjects = db.select().from(schema.projects).where(eq(schema.projects.type, "non-git")).all();
-      expect(nonGitProjects).toHaveLength(1);
-      expect(nonGitProjects[0]!.projectMarker).toBe("package.json");
-    });
-
-    test("stores and retrieves status JSON", () => {
-      const status = {
-        isDirty: true,
-        hasUnstagedChanges: true,
-        modifiedCount: 5,
-        currentBranch: "main",
-      };
-
-      const project = {
-        id: "status-test",
-        name: "status-project",
-        path: "/path/status",
-        type: "git",
-        statusJson: JSON.stringify(status),
-      };
-
-      db.insert(schema.projects).values(project).run();
-
-      const result = db.select().from(schema.projects).where(eq(schema.projects.id, "status-test")).all();
-      const retrievedStatus = JSON.parse(result[0]!.statusJson!);
-
-      expect(retrievedStatus.isDirty).toBe(true);
-      expect(retrievedStatus.modifiedCount).toBe(5);
-      expect(retrievedStatus.currentBranch).toBe("main");
-    });
-
-    // New tests for project cache functionality
-    describe("project cache operations", () => {
-      test("saves projects to cache", () => {
-        const projects = [
-          { id: "cache-1", name: "cached-1", path: "/cache/1", type: "git" },
-          { id: "cache-2", name: "cached-2", path: "/cache/2", type: "git" },
-        ];
-
-        // Save multiple projects
-        for (const project of projects) {
-          db.insert(schema.projects).values(project).run();
-        }
-
-        const allProjects = db.select().from(schema.projects).all();
-        expect(allProjects).toHaveLength(2);
-        expect(allProjects.map(p => p.name)).toEqual(["cached-1", "cached-2"]);
-      });
-
-      test("loads projects from cache", () => {
-        // Insert test data
-        db.insert(schema.projects).values([
-          { id: "load-1", name: "load-test-1", path: "/load/1", type: "git" },
-          { id: "load-2", name: "load-test-2", path: "/load/2", type: "non-git" },
-        ]).run();
-
-        // Load all projects
-        const allProjects = db.select().from(schema.projects).all();
-        expect(allProjects).toHaveLength(2);
-
-        // Load specific project by ID
-        const projectById = db.select().from(schema.projects)
-          .where(eq(schema.projects.id, "load-1"))
-          .all();
-        expect(projectById).toHaveLength(1);
-        expect(projectById[0]!.name).toBe("load-test-1");
-
-        // Load by type
-        const gitProjects = db.select().from(schema.projects)
-          .where(eq(schema.projects.type, "git"))
-          .all();
-        expect(gitProjects).toHaveLength(1);
-        expect(gitProjects[0]!.id).toBe("load-1");
-      });
-
-      test("updates existing projects (upsert)", () => {
-        const initialProject = {
-          id: "upsert-test",
-          name: "initial-name",
-          path: "/upsert/test",
-          type: "git",
-          lastScanned: new Date("2023-01-01"),
-        };
-
-        // Insert initial project
-        db.insert(schema.projects).values(initialProject).run();
-
-        // Update with upsert pattern
-        const updatedProject = {
-          id: "upsert-test",
-          name: "updated-name",
-          path: "/upsert/test",
-          type: "git",
-          lastScanned: new Date("2023-12-31"),
-        };
-
-        // SQLite doesn't have native upsert, so we delete then insert
-        db.delete(schema.projects).where(eq(schema.projects.id, "upsert-test")).run();
-        db.insert(schema.projects).values(updatedProject).run();
-
-        const result = db.select().from(schema.projects)
-          .where(eq(schema.projects.id, "upsert-test"))
-          .all();
-
-        expect(result).toHaveLength(1);
-        expect(result[0]!.name).toBe("updated-name");
-        expect(result[0]!.lastScanned).toEqual(updatedProject.lastScanned);
-      });
-
-      test("cache TTL expiration logic", () => {
-        // Insert projects with different lastScanned times
-        const now = new Date();
-        const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);
-        const twoDaysAgo = new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000);
-
-        db.insert(schema.projects).values([
-          { id: "fresh", name: "fresh", path: "/fresh", type: "git", lastScanned: now },
-          { id: "hour-old", name: "hour-old", path: "/hour", type: "git", lastScanned: oneHourAgo },
-          { id: "expired", name: "expired", path: "/expired", type: "git", lastScanned: twoDaysAgo },
-        ]).run();
-
-        // Get all projects and filter manually (simulating TTL check)
-        const allProjects = db.select().from(schema.projects).all();
-        const oneDayAgo = now.getTime() - (24 * 60 * 60 * 1000);
-        const expiredProjects = allProjects.filter(p => {
-          if (!p.lastScanned) return false;
-          return new Date(p.lastScanned).getTime() < oneDayAgo;
-        });
-
-        expect(expiredProjects).toHaveLength(1);
-        expect(expiredProjects[0]!.id).toBe("expired");
-      });
-    });
-  });
-
-  describe("remote_status table", () => {
-    test("inserts remote status for project", () => {
-      // First create a project
-      db.insert(schema.projects).values({
-        id: "project-with-remote",
-        name: "remote-project",
-        path: "/path/remote",
-        type: "git",
-      }).run();
-
-      // Then add remote status
-      db.insert(schema.remoteStatus).values({
-        projectId: "project-with-remote",
-        lastFetched: new Date(),
-        unpulledCommits: 3,
-        remoteUrl: "git@github.com:user/repo.git",
-      }).run();
-
-      const result = db.select().from(schema.remoteStatus).all();
-      expect(result).toHaveLength(1);
-      expect(result[0]!.unpulledCommits).toBe(3);
-      expect(result[0]!.remoteUrl).toBe("git@github.com:user/repo.git");
-    });
-
-    test("updates remote status", () => {
-      db.insert(schema.projects).values({
-        id: "update-remote",
-        name: "project",
-        path: "/path/update-remote",
-        type: "git",
-      }).run();
-
-      db.insert(schema.remoteStatus).values({
-        projectId: "update-remote",
-        unpulledCommits: 1,
-      }).run();
-
-      db.update(schema.remoteStatus)
-        .set({ unpulledCommits: 5 })
-        .where(eq(schema.remoteStatus.projectId, "update-remote"))
-        .run();
-
-      const result = db.select().from(schema.remoteStatus).where(eq(schema.remoteStatus.projectId, "update-remote")).all();
-      expect(result[0]!.unpulledCommits).toBe(5);
-    });
-
-    // New tests for remote status
-    describe("remote status operations", () => {
-      test("saves remote status", () => {
-        // Create project first
-        db.insert(schema.projects).values({
-          id: "save-remote",
-          name: "save-remote-project",
-          path: "/save/remote",
-          type: "git",
-        }).run();
-
-        const remoteStatus = {
-          projectId: "save-remote",
-          lastFetched: new Date(),
-          unpulledCommits: 5,
-          remoteLastActivity: new Date(Date.now() - 3600000), // 1 hour ago
-          remoteUrl: "https://github.com/test/repo.git",
-        };
-
-        db.insert(schema.remoteStatus).values(remoteStatus).run();
-
-        const saved = db.select().from(schema.remoteStatus)
-          .where(eq(schema.remoteStatus.projectId, "save-remote"))
-          .all();
-
-        expect(saved).toHaveLength(1);
-        expect(saved[0]!.unpulledCommits).toBe(5);
-        expect(saved[0]!.remoteUrl).toBe("https://github.com/test/repo.git");
-      });
-
-      test("loads remote status", () => {
-        // Create project and remote status
-        db.insert(schema.projects).values({
-          id: "load-remote",
-          name: "load-remote-project",
-          path: "/load/remote",
-          type: "git",
-        }).run();
-
-        db.insert(schema.remoteStatus).values({
-          projectId: "load-remote",
-          unpulledCommits: 10,
-          remoteUrl: "git@github.com:user/repo.git",
-        }).run();
-
-        // Load by project ID
-        const result = db.select().from(schema.remoteStatus)
-          .where(eq(schema.remoteStatus.projectId, "load-remote"))
-          .all();
-
-        expect(result).toHaveLength(1);
-        expect(result[0]!.unpulledCommits).toBe(10);
-      });
-
-      test("cascade delete when project deleted", () => {
-        // Create project
-        db.insert(schema.projects).values({
-          id: "cascade-test",
-          name: "cascade-project",
-          path: "/cascade/test",
-          type: "git",
-        }).run();
-
-        // Create remote status
-        db.insert(schema.remoteStatus).values({
-          projectId: "cascade-test",
-          unpulledCommits: 2,
-        }).run();
-
-        // Verify both exist
-        expect(db.select().from(schema.projects).all()).toHaveLength(1);
-        expect(db.select().from(schema.remoteStatus).all()).toHaveLength(1);
-
-        // Delete project
-        db.delete(schema.projects).where(eq(schema.projects.id, "cascade-test")).run();
-
-        // Verify remote status was also deleted (cascade)
-        expect(db.select().from(schema.projects).all()).toHaveLength(0);
-        expect(db.select().from(schema.remoteStatus).all()).toHaveLength(0);
-      });
-    });
-  });
-
-  describe("config_cache table", () => {
-    test("stores config values", () => {
-      db.insert(schema.configCache).values({
-        key: "last_config_hash",
-        value: "abc123",
-        updatedAt: new Date(),
-      }).run();
-
-      const result = db.select().from(schema.configCache).where(eq(schema.configCache.key, "last_config_hash")).all();
-      expect(result).toHaveLength(1);
-      expect(result[0]!.value).toBe("abc123");
-    });
-
-    test("updates config values with upsert pattern", () => {
-      const key = "test_key";
-
-      // Insert initial value
-      db.insert(schema.configCache).values({
-        key,
-        value: "initial",
-        updatedAt: new Date(),
-      }).run();
-
-      // Update with new value
-      db.update(schema.configCache)
-        .set({ value: "updated", updatedAt: new Date() })
-        .where(eq(schema.configCache.key, key))
-        .run();
-
-      const result = db.select().from(schema.configCache).where(eq(schema.configCache.key, key)).all();
-      expect(result[0]!.value).toBe("updated");
-    });
-
-    // New tests for config cache
-    describe("config cache operations", () => {
-      test("saves config values", () => {
-        const configValues = [
-          { key: "github_token", value: "ghp_123456", updatedAt: new Date() },
-          { key: "theme", value: "dark", updatedAt: new Date() },
-          { key: "auto_refresh", value: "true", updatedAt: new Date() },
-        ];
-
-        for (const config of configValues) {
-          db.insert(schema.configCache).values(config).run();
-        }
-
-        const allConfigs = db.select().from(schema.configCache).all();
-        expect(allConfigs).toHaveLength(3);
-        expect(allConfigs.map(c => c.key).sort()).toEqual(["auto_refresh", "github_token", "theme"]);
-      });
-
-      test("loads config values", () => {
-        // Insert test configs
-        db.insert(schema.configCache).values([
-          { key: "load_test_1", value: "value1", updatedAt: new Date("2023-01-01") },
-          { key: "load_test_2", value: "value2", updatedAt: new Date("2023-12-31") },
-        ]).run();
-
-        // Load single config
-        const config1 = db.select().from(schema.configCache)
-          .where(eq(schema.configCache.key, "load_test_1"))
-          .all();
-        expect(config1).toHaveLength(1);
-        expect(config1[0]!.value).toBe("value1");
-
-        // Load all configs
-        const allConfigs = db.select().from(schema.configCache).all();
-        expect(allConfigs).toHaveLength(2);
-      });
-
-      test("updates config values", () => {
-        const key = "update_test";
-        const initialDate = new Date("2023-01-01");
-        const updatedDate = new Date("2023-12-31");
-
-        // Initial insert
-        db.insert(schema.configCache).values({
-          key,
-          value: "initial_value",
-          updatedAt: initialDate,
-        }).run();
-
-        // Update
-        db.update(schema.configCache)
-          .set({ 
-            value: "updated_value",
-            updatedAt: updatedDate,
-          })
-          .where(eq(schema.configCache.key, key))
-          .run();
-
-        const result = db.select().from(schema.configCache)
-          .where(eq(schema.configCache.key, key))
-          .all();
-
-        expect(result).toHaveLength(1);
-        expect(result[0]!.value).toBe("updated_value");
-        expect(new Date(result[0]!.updatedAt!)).toEqual(updatedDate);
-      });
-    });
-  });
-
-  describe("github_repos table", () => {
-    describe("GitHub repos cache operations", () => {
-      test("saves github repos", () => {
-        const repos = [
-          {
-            id: 1,
-            name: "repo1",
-            fullName: "user1/repo1",
-            owner: "user1",
-            description: "Test repo 1",
-            htmlUrl: "https://github.com/user1/repo1",
-            isPrivate: false,
-            isArchived: false,
-            isFork: false,
-            pushedAt: new Date("2023-12-01"),
-            updatedAt: new Date("2023-12-15"),
-            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: new Date(),
-          },
-          {
-            id: 2,
-            name: "repo2",
-            fullName: "user2/repo2",
-            owner: "user2",
-            description: "Test repo 2",
-            htmlUrl: "https://github.com/user2/repo2",
-            isPrivate: true,
-            isArchived: false,
-            isFork: true,
-            pushedAt: new Date("2023-11-15"),
-            updatedAt: new Date("2023-11-20"),
-            defaultBranch: "master",
-            language: "JavaScript",
-            size: 2048,
-            stargazersCount: 50,
-            forksCount: 10,
-            openIssuesCount: 3,
-            watchersCount: 25,
-            topics: JSON.stringify(["javascript", "node"]),
-            license: "Apache-2.0",
-            hasIssues: true,
-            hasWiki: false,
-            hasDiscussions: true,
-            lastFetched: new Date(),
-          },
-        ];
-
-        for (const repo of repos) {
-          db.insert(schema.githubRepos).values(repo).run();
-        }
-
-        const allRepos = db.select().from(schema.githubRepos).all();
-        expect(allRepos).toHaveLength(2);
-        expect(allRepos[0]!.fullName).toBe("user1/repo1");
-        expect(allRepos[1]!.fullName).toBe("user2/repo2");
-      });
-
-      test("loads github repos", () => {
-        // Insert test repos
-        db.insert(schema.githubRepos).values([
-          {
-            id: 101,
-            name: "load-test",
-            fullName: "testuser/load-test",
-            owner: "testuser",
-            description: "Load test repo",
-            lastFetched: new Date(),
-          },
-          {
-            id: 102,
-            name: "another-test",
-            fullName: "anotheruser/another-test",
-            owner: "anotheruser",
-            description: "Another test repo",
-            lastFetched: new Date(),
-          },
-        ]).run();
-
-        // Load all repos
-        const allRepos = db.select().from(schema.githubRepos).all();
-        expect(allRepos).toHaveLength(2);
-
-        // Load by ID
-        const repoById = db.select().from(schema.githubRepos)
-          .where(eq(schema.githubRepos.id, 101))
-          .all();
-        expect(repoById).toHaveLength(1);
-        expect(repoById[0]!.name).toBe("load-test");
-      });
-
-      test("filters by owner", () => {
-        // Insert repos with different owners
-        db.insert(schema.githubRepos).values([
-          {
-            id: 201,
-            name: "repo1",
-            fullName: "owner1/repo1",
-            owner: "owner1",
-            lastFetched: new Date(),
-          },
-          {
-            id: 202,
-            name: "repo2",
-            fullName: "owner1/repo2",
-            owner: "owner1",
-            lastFetched: new Date(),
-          },
-          {
-            id: 203,
-            name: "repo3",
-            fullName: "owner2/repo3",
-            owner: "owner2",
-            lastFetched: new Date(),
-          },
-        ]).run();
-
-        // Filter by owner1
-        const owner1Repos = db.select().from(schema.githubRepos)
-          .where(eq(schema.githubRepos.owner, "owner1"))
-          .all();
-
-        expect(owner1Repos).toHaveLength(2);
-        expect(owner1Repos.every(r => r.owner === "owner1")).toBe(true);
-
-        // Filter by owner2
-        const owner2Repos = db.select().from(schema.githubRepos)
-          .where(eq(schema.githubRepos.owner, "owner2"))
-          .all();
-
-        expect(owner2Repos).toHaveLength(1);
-        expect(owner2Repos[0]!.name).toBe("repo3");
-      });
-
-      test("last_fetched timestamp", () => {
-        // Insert repos with different fetch times
-        const now = new Date();
-        const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);
-        const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-
-        db.insert(schema.githubRepos).values([
-          {
-            id: 301,
-            name: "fresh",
-            fullName: "test/fresh",
-            owner: "test",
-            lastFetched: now,
-          },
-          {
-            id: 302,
-            name: "hour-old",
-            fullName: "test/hour-old",
-            owner: "test",
-            lastFetched: oneHourAgo,
-          },
-          {
-            id: 303,
-            name: "stale",
-            fullName: "test/stale",
-            owner: "test",
-            lastFetched: yesterday,
-          },
-        ]).run();
-
-        // Get all repos and filter manually (simulating stale check)
-        const allRepos = db.select().from(schema.githubRepos).all();
-        const twoHoursAgo = now.getTime() - (2 * 60 * 60 * 1000);
-        const staleRepos = allRepos.filter(r => {
-          if (!r.lastFetched) return false;
-          return new Date(r.lastFetched).getTime() < twoHoursAgo;
-        });
-
-        expect(staleRepos).toHaveLength(1);
-        expect(staleRepos[0]!.name).toBe("stale");
-      });
-    });
-  });
-
-  describe("database operations", () => {
-    test("clears all projects", () => {
-      // Insert some projects
-      db.insert(schema.projects).values([
-        { id: "p1", name: "project-1", path: "/path/1", type: "git" },
-        { id: "p2", name: "project-2", path: "/path/2", type: "git" },
-        { id: "p3", name: "project-3", path: "/path/3", type: "non-git" },
-      ]).run();
-
-      // Verify they exist
-      let result = db.select().from(schema.projects).all();
-      expect(result).toHaveLength(3);
-
-      // Clear all
-      db.delete(schema.projects).run();
-
-      // Verify empty
-      result = db.select().from(schema.projects).all();
-      expect(result).toHaveLength(0);
-    });
-
-    test("filters by type", () => {
-      db.insert(schema.projects).values([
-        { id: "g1", name: "git-1", path: "/git/1", type: "git" },
-        { id: "g2", name: "git-2", path: "/git/2", type: "git" },
-        { id: "n1", name: "non-1", path: "/non/1", type: "non-git" },
-        { id: "s1", name: "sub-1", path: "/sub/1", type: "git-submodule" },
-      ]).run();
-
-      const gitOnly = db.select()
-        .from(schema.projects)
-        .where(eq(schema.projects.type, "git"))
-        .all();
-
-      expect(gitOnly).toHaveLength(2);
-      expect(gitOnly.every(p => p.type === "git")).toBe(true);
-    });
-  });
-
-  describe("error handling", () => {
-    test("handles database initialization errors", () => {
-      // This would be tested in the actual initDb function
-      // For now, we can simulate with a bad query
-      expect(() => {
-        sqliteDb.run("INVALID SQL");
-      }).toThrow();
-    });
-
-    test("handles write errors", () => {
-      // Try to insert duplicate primary key
-      db.insert(schema.projects).values({
-        id: "duplicate",
-        name: "project-1",
-        path: "/path/1",
-        type: "git",
-      }).run();
-
-      expect(() => {
-        db.insert(schema.projects).values({
-          id: "duplicate", // Same ID
-          name: "project-2",
-          path: "/path/2",
-          type: "git",
-        }).run();
-      }).toThrow();
-    });
-
-    test("handles read errors on non-existent data", () => {
-      // Query non-existent data
-      const result = db.select().from(schema.projects)
-        .where(eq(schema.projects.id, "non-existent"))
-        .all();
-
-      expect(result).toHaveLength(0);
-    });
-
-    test("handles database cleanup", () => {
-      // Insert some data
-      db.insert(schema.projects).values({
-        id: "cleanup-test",
-        name: "cleanup",
-        path: "/cleanup",
-        type: "git",
-      }).run();
-
-      // Verify data exists
-      expect(db.select().from(schema.projects).all()).toHaveLength(1);
-
-      // Close database (simulating cleanup)
-      sqliteDb.close();
-
-      // Attempting to use closed database should throw
-      expect(() => {
-        sqliteDb.run("SELECT 1");
-      }).toThrow();
-    });
-  });
-
-  describe("edge cases", () => {
-    test("handles empty database operations", () => {
-      // Verify empty database
-      expect(db.select().from(schema.projects).all()).toHaveLength(0);
-      expect(db.select().from(schema.remoteStatus).all()).toHaveLength(0);
-      expect(db.select().from(schema.githubRepos).all()).toHaveLength(0);
-      expect(db.select().from(schema.configCache).all()).toHaveLength(0);
-    });
-
-    test("handles large batch inserts", () => {
-      const batchSize = 100;
-      const projects = Array.from({ length: batchSize }, (_, i) => ({
-        id: `batch-${i}`,
-        name: `Batch Project ${i}`,
-        path: `/batch/${i}`,
-        type: i % 3 === 0 ? "git" : i % 3 === 1 ? "non-git" : "git-submodule",
-      }));
-
-      // Insert large batch
-      const start = Date.now();
-      for (const project of projects) {
-        db.insert(schema.projects).values(project).run();
-      }
-      const duration = Date.now() - start;
-
-      // Verify all inserted
-      const allProjects = db.select().from(schema.projects).all();
-      expect(allProjects).toHaveLength(batchSize);
-
-      // Performance check - should complete reasonably fast
-      expect(duration).toBeLessThan(5000); // 5 seconds max
-    });
-
-    test("handles special characters in data", () => {
-      const specialProject = {
-        id: "special-chars",
-        name: "Project with 'quotes' and \"double quotes\"",
-        path: "/path/with spaces and 'quotes'",
-        type: "git",
-        statusJson: JSON.stringify({
-          message: "Status with \"quotes\" and 'apostrophes'",
-          path: "/path/with/unicode/字符/🔥",
-        }),
-      };
-
-      db.insert(schema.projects).values(specialProject).run();
-
-      const result = db.select().from(schema.projects)
-        .where(eq(schema.projects.id, "special-chars"))
-        .all();
-
-      expect(result).toHaveLength(1);
-      const retrievedStatus = JSON.parse(result[0]!.statusJson!);
-      expect(retrievedStatus.message).toBe("Status with \"quotes\" and 'apostrophes'");
-      expect(retrievedStatus.path).toBe("/path/with/unicode/字符/🔥");
-    });
-
-    test("handles concurrent-like access patterns", () => {
-      // Simulate rapid inserts and updates
-      const operations = Array.from({ length: 50 }, (_, i) => {
-        const id = `concurrent-${i}`;
-        return {
-          id,
-          name: `Concurrent ${i}`,
-          path: `/concurrent/${i}`,
-          type: "git",
-        };
-      });
-
-      // Perform all inserts
-      for (const op of operations) {
-        db.insert(schema.projects).values(op).run();
-      }
-
-      // Perform updates
-      for (let i = 0; i < 25; i++) {
-        db.update(schema.projects)
-          .set({ name: `Updated ${i}` })
-          .where(eq(schema.projects.id, `concurrent-${i}`))
-          .run();
-      }
-
-      // Verify results
-      const allProjects = db.select().from(schema.projects).all();
-      expect(allProjects).toHaveLength(50);
-
-      const updatedProjects = db.select().from(schema.projects)
-        .where(sql`${schema.projects.name} LIKE 'Updated %'`)
-        .all();
-      expect(updatedProjects).toHaveLength(25);
-    });
-  });
-
-  describe("clearCache function", () => {
-    test("clears all cached data", () => {
-      // Insert data into all tables
-      db.insert(schema.projects).values([
-        { id: "clear-1", name: "Clear 1", path: "/clear/1", type: "git" },
-        { id: "clear-2", name: "Clear 2", path: "/clear/2", type: "non-git" },
-      ]).run();
-
-      db.insert(schema.remoteStatus).values({
-        projectId: "clear-1",
-        unpulledCommits: 5,
-      }).run();
-
-      db.insert(schema.githubRepos).values({
-        id: 401,
-        name: "clear-repo",
-        fullName: "clear/clear-repo",
-        owner: "clear",
-        lastFetched: new Date(),
-      }).run();
-
-      db.insert(schema.configCache).values({
-        key: "clear_test",
-        value: "test_value",
-        updatedAt: new Date(),
-      }).run();
-
-      // Verify data exists
-      expect(db.select().from(schema.projects).all()).toHaveLength(2);
-      expect(db.select().from(schema.remoteStatus).all()).toHaveLength(1);
-      expect(db.select().from(schema.githubRepos).all()).toHaveLength(1);
-      expect(db.select().from(schema.configCache).all()).toHaveLength(1);
-
-      // Clear cache
-      db.delete(schema.projects).run();
-      db.delete(schema.remoteStatus).run();
-
-      // Verify projects and remote status are cleared
-      expect(db.select().from(schema.projects).all()).toHaveLength(0);
-      expect(db.select().from(schema.remoteStatus).all()).toHaveLength(0);
-      
-      // Other tables remain intact
-      expect(db.select().from(schema.githubRepos).all()).toHaveLength(1);
-      expect(db.select().from(schema.configCache).all()).toHaveLength(1);
-    });
-  });
-});