logs

Author: AmirSa12

packages/app/server/api/repos.get.ts

@@ -7,16 +7,65 @@ export default defineEventHandler(async (event) => {
     // Use R2 service
     const r2Service = useR2GitHubService(event);
 
-    // Get all repositories from R2
+    // First, dump all storage keys for debugging
+    console.log("[R2API] Dumping R2 storage structure for debugging");
+    const storageKeys = await r2Service.dumpStorageKeys();
+    console.log(`[R2API] R2 storage has ${storageKeys.total_keys} total keys`);
+
+    // Get sample values to understand the data structure
+    const sampleValues = await r2Service.getSampleValues();
+    console.log(
+      `[R2API] Got ${sampleValues.sample_count || 0} sample values from R2`,
+    );
+
+    // Try to get all repositories directly from storage keys
+    console.log("[R2API] Attempting to scan all keys for repositories");
+    // Use the getStorageAccess method to access storage safely
+    const storageAccess = r2Service.getStorageAccess();
+    const allKeys = await storageAccess.getKeys();
+    const repoKeys = allKeys.filter((key) => key.startsWith("repo:"));
+    console.log(`[R2API] Found ${repoKeys.length} repository keys`);
+
+    // Directly load repositories from keys
+    const loadedRepositories = [];
+    for (const key of repoKeys) {
+      try {
+        const data = await storageAccess.getItem(key);
+        if (data) {
+          const repo = typeof data === "string" ? JSON.parse(data) : data;
+          console.log(
+            `[R2API] Successfully loaded repository from key: ${key}`,
+          );
+          loadedRepositories.push(repo);
+        }
+      } catch (error) {
+        console.error(
+          `[R2API] Error loading repository from key ${key}:`,
+          error,
+        );
+      }
+    }
+
+    console.log(
+      `[R2API] Directly loaded ${loadedRepositories.length} repositories from keys`,
+    );
+
+    // Also try the original method
     const repositories = await r2Service.listAllRepositories();
+    console.log(
+      `[R2API] Found ${repositories.length} repositories using listAllRepositories()`,
+    );
 
+    // Determine which set of repositories to use
+    const effectiveRepositories =
+      loadedRepositories.length > 0 ? loadedRepositories : repositories;
     console.log(
-      `[R2API] Found ${repositories.length} repositories in R2 storage`,
+      `[R2API] Using ${effectiveRepositories.length} repositories for response`,
     );
 
     // Get latest commit for each repository
     const reposWithLatestCommit = await Promise.all(
-      repositories.map(async (repo) => {
+      effectiveRepositories.map(async (repo) => {
         try {
           const commits = await r2Service.listCommits(
             repo.owner.login,
@@ -79,10 +128,16 @@ export default defineEventHandler(async (event) => {
     const clientDebugInfo = {
       timestamp: new Date().toISOString(),
       storage_info: r2Service.getStorageInfo(),
-      repository_count: repositories.length,
-      repository_names: repositories.map(
+      repository_count: effectiveRepositories.length,
+      repository_names: effectiveRepositories.map(
         (repo) => `${repo.owner.login}/${repo.name}`,
       ),
+      storage_structure: {
+        total_keys: storageKeys.total_keys,
+        key_counts: storageKeys.key_counts,
+        key_samples: storageKeys.key_samples,
+      },
+      sample_values: sampleValues,
     };
 
     return {

packages/app/server/utils/r2-service.ts

@@ -459,6 +459,125 @@ export class R2GitHubService {
     }
   }
 
+  // Get full details of all keys in the storage for debugging
+  async dumpStorageKeys(): Promise<{
+    total_keys: number;
+    key_counts: Record<string, number>;
+    key_samples: Record<string, string[]>;
+    all_keys: string[];
+  }> {
+    try {
+      this.log("Dumping all storage keys for debugging");
+      const keys = await this.storage.getKeys();
+      this.log(`Found ${keys.length} total keys in storage`);
+
+      // Organize keys by prefix for better debugging
+      const keysByPrefix: Record<string, string[]> = {};
+
+      keys.forEach((key) => {
+        const prefix = key.split(":")[0] || "unknown";
+        if (!keysByPrefix[prefix]) {
+          keysByPrefix[prefix] = [];
+        }
+        keysByPrefix[prefix].push(key);
+      });
+
+      // Count each type
+      const counts: Record<string, number> = {};
+      Object.keys(keysByPrefix).forEach((prefix) => {
+        counts[prefix] = keysByPrefix[prefix].length;
+      });
+
+      this.log(`Key counts by prefix: ${JSON.stringify(counts)}`);
+
+      // Sample a few keys from each prefix (max 5)
+      const samples: Record<string, string[]> = {};
+      Object.keys(keysByPrefix).forEach((prefix) => {
+        samples[prefix] = keysByPrefix[prefix].slice(0, 5);
+      });
+
+      return {
+        total_keys: keys.length,
+        key_counts: counts,
+        key_samples: samples,
+        all_keys: keys,
+      };
+    } catch (error) {
+      this.log(`Error dumping storage keys: ${error}`, true);
+      return {
+        total_keys: 0,
+        key_counts: {},
+        key_samples: {},
+        all_keys: [],
+      };
+    }
+  }
+
+  // Get a few sample values to see the structure
+  async getSampleValues(): Promise<{
+    sample_count: number;
+    samples: Record<string, any>;
+    error?: string;
+  }> {
+    try {
+      this.log("Fetching sample values from storage for debugging");
+      const keys = await this.storage.getKeys();
+
+      if (keys.length === 0) {
+        return {
+          sample_count: 0,
+          samples: {},
+          error: "No keys found in storage",
+        };
+      }
+
+      // Sample up to 5 keys of different types
+      const sampleValues: Record<string, any> = {};
+      const prefixes = ["repo:", "commit:", "check-run:", "search-index"];
+
+      for (const prefix of prefixes) {
+        const matchingKeys = keys
+          .filter((key) => key.startsWith(prefix))
+          .slice(0, 2);
+        if (matchingKeys.length > 0) {
+          sampleValues[prefix] = {};
+          for (const key of matchingKeys) {
+            try {
+              const value = await this.storage.getItem(key);
+              if (value) {
+                sampleValues[prefix][key] =
+                  typeof value === "string" ? JSON.parse(value) : value;
+              }
+            } catch (error) {
+              sampleValues[prefix][key] = `Error parsing value: ${error}`;
+            }
+          }
+        }
+      }
+
+      return {
+        sample_count: Object.keys(sampleValues).length,
+        samples: sampleValues,
+      };
+    } catch (error) {
+      this.log(`Error getting sample values: ${error}`, true);
+      return {
+        sample_count: 0,
+        samples: {},
+        error: `Could not get sample values: ${error}`,
+      };
+    }
+  }
+
+  // Expose the storage for debugging purposes
+  // This is normally not recommended but useful for debugging R2 issues
+  getStorageAccess() {
+    return {
+      getKeys: async () => await this.storage.getKeys(),
+      getItem: async (key: string) => await this.storage.getItem(key),
+    };
+  }
+
   // Index methods - fetching data from GitHub and storing in R2
   async indexRepository(owner: string, repo: string): Promise<void> {
     try {