gitforest 0.1.0

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

@@ -0,0 +1,978 @@
+/**
+ * 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);
+    });
+  });
+});