first pass at preloading gradeables when loading extension

Author: rileyallyn

src/extension.ts

@@ -3,17 +3,44 @@ import { SidebarProvider } from './sidebarProvider';
 import { ApiService } from './services/apiService';
 import { TestingService } from './services/testingService';
 import { GitService } from './services/gitService';
+import { AuthService } from './services/authService';
+import { CourseRepoResolver } from './services/courseRepoResolver';
+import type { Gradable } from './interfaces/Gradables';
 
 export function activate(context: vscode.ExtensionContext): void {
     const apiService = ApiService.getInstance(context, '');
     const testingService = new TestingService(context, apiService);
     const gitService = new GitService();
+    const authService = AuthService.getInstance(context);
     const sidebarProvider = new SidebarProvider(context, testingService, gitService);
 
     context.subscriptions.push(
         vscode.window.registerWebviewViewProvider('submittyWebview', sidebarProvider)
     );
 
+    // Preload gradables into the Test Explorer when the workspace appears
+    // to be a course-tied repo.
+    void (async () => {
+        try {
+            await authService.initialize();
+            const resolver = new CourseRepoResolver(apiService, authService, gitService);
+            const courseContext = await resolver.resolveCourseContextFromRepo();
+            if (!courseContext) {
+                return;
+            }
+
+            const gradablesResponse = await apiService.fetchGradables(courseContext.courseId, courseContext.term);
+            const gradables = Object.values(gradablesResponse.data);
+
+            for (const g of gradables) {
+                testingService.addGradeable(courseContext.term, courseContext.courseId, g.id, g.title || g.id);
+            }
+        } catch (e) {
+            const err = e instanceof Error ? e.message : String(e);
+            console.warn(`Failed to preload gradables: ${err}`);
+        }
+    })();
+
 }
 
 export function deactivate() { }

src/services/apiService.ts

@@ -2,10 +2,22 @@
 
 import * as vscode from 'vscode';
 import { ApiClient } from './apiClient';
-
 import { CourseResponse, LoginResponse, GradableResponse } from '../interfaces/Responses';
 import { AutoGraderDetails } from '../interfaces/AutoGraderDetails';
 
+function getErrorMessage(error: unknown, fallback: string): string {
+    if (error instanceof Error) {
+        return error.message || fallback;
+    }
+    if (typeof error === 'object' && error) {
+        const maybeAxiosError = error as { response?: { data?: { message?: unknown } } };
+        const msg = maybeAxiosError.response?.data?.message;
+        if (typeof msg === 'string' && msg.trim()) {
+            return msg;
+        }
+    }
+    return fallback;
+}
 
 export class ApiService {
     private client: ApiClient;
@@ -16,12 +28,12 @@ export class ApiService {
     }
 
     // set token for local api client
-    setAuthorizationToken(token: string) {
+    setAuthorizationToken(token: string): void {
         this.client.setToken(token);
     }
 
     // set base URL for local api client
-    setBaseUrl(baseUrl: string) {
+    setBaseUrl(baseUrl: string): void {
         this.client.setBaseURL(baseUrl);
     }
 
@@ -43,31 +55,31 @@ export class ApiService {
 
             const token: string = response.data.data.token;
             return token;
-        } catch (error: any) {
-            throw new Error(error.response?.data?.message || error.message || 'Login failed.');
+        } catch (error: unknown) {
+            throw new Error(getErrorMessage(error, 'Login failed.'));
         }
     }
 
     async fetchMe(): Promise<any> {
         try {
             const response = await this.client.get<any>('/api/me');
             return response.data;
-        } catch (error: any) {
-            throw new Error(error.response?.data?.message || 'Failed to fetch me.');
+        } catch (error: unknown) {
+            throw new Error(getErrorMessage(error, 'Failed to fetch me.'));
         }
     }
 
 
     /**
      * Fetch all courses for the authenticated user
      */
-    async fetchCourses(token?: string): Promise<CourseResponse> {
+    async fetchCourses(_token?: string): Promise<CourseResponse> {
         try {
             const response = await this.client.get<CourseResponse>('/api/courses');
             return response.data;
-        } catch (error: any) {
+        } catch (error: unknown) {
             console.error('Error fetching courses:', error);
-            throw new Error(error.response?.data?.message || 'Failed to fetch courses.');
+            throw new Error(getErrorMessage(error, 'Failed to fetch courses.'));
         }
     }
 
@@ -76,9 +88,9 @@ export class ApiService {
             const url = `/api/${term}/${courseId}/gradeables`;
             const response = await this.client.get<GradableResponse>(url);
             return response.data;
-        } catch (error: any) {
+        } catch (error: unknown) {
             console.error('Error fetching gradables:', error);
-            throw new Error(error.response?.data?.message || 'Failed to fetch gradables.');
+            throw new Error(getErrorMessage(error, 'Failed to fetch gradables.'));
         }
     }
 
@@ -89,9 +101,9 @@ export class ApiService {
         try {
             const response = await this.client.get<AutoGraderDetails>(`/api/${term}/${courseId}/gradeable/${gradeableId}/values`);
             return response.data;
-        } catch (error: any) {
+        } catch (error: unknown) {
             console.error('Error fetching grade details:', error);
-            throw new Error(error.response?.data?.message || 'Failed to fetch grade details.');
+            throw new Error(getErrorMessage(error, 'Failed to fetch grade details.'));
         }
     }
 
@@ -140,24 +152,24 @@ export class ApiService {
             const url = `/api/${term}/${courseId}/gradeable/${gradeableId}/upload?vcs_upload=true&git_repo_id=true`;
             const response = await this.client.post<any>(url);
             return response.data;
-        } catch (error: any) {
-            console.error('Error submitting VCS gradable:', error);
-            throw new Error(error.response?.data?.message || 'Failed to submit VCS gradable.');
+        } catch (error: unknown) {
+            console.error('Error submitt`ing VCS gradable:', error);
+            throw new Error(getErrorMessage(error, 'Failed to submit VCS gradable.'));
         }
     }
 
 
     /**
      * Fetch previous attempts for a specific homework assignment
      */
-    async fetchPreviousAttempts(term: string, courseId: string, gradeableId: string): Promise<any[]> {
+    async fetchPreviousAttempts(term: string, courseId: string, gradeableId: string): Promise<unknown[]> {
         try {
             const url = `/api/${term}/${courseId}/gradeable/${gradeableId}/attempts`;
-            const response = await this.client.get<any>(url);
+            const response = await this.client.get<unknown[]>(url);
             return response.data;
-        } catch (error: any) {
+        } catch (error: unknown) {
             console.error('Error fetching previous attempts:', error);
-            throw new Error(error.response?.data?.message || 'Failed to fetch previous attempts.');
+            throw new Error(getErrorMessage(error, 'Failed to fetch previous attempts.'));
         }
     }
 

src/services/authService.ts

@@ -13,7 +13,7 @@ export class AuthService {
         this.apiService = ApiService.getInstance(context, "");
     }
 
-    async initialize() {
+    async initialize(): Promise<void> {
         console.log("Initializing AuthService");
 
         // Get base URL from configuration
@@ -31,6 +31,36 @@ export class AuthService {
             // Token exists, set it on the API service
             this.apiService.setAuthorizationToken(token);
             console.log("Token set on API service");
+
+            // If baseUrl isn't configured yet, fetch it now so API calls work.
+            if (!baseUrl) {
+                const inputUrl = await vscode.window.showInputBox({
+                    prompt: 'Enter Submitty API URL',
+                    placeHolder: 'https://example.submitty.edu',
+                    ignoreFocusOut: true,
+                    validateInput: (value) => {
+                        if (!value || value.trim().length === 0) {
+                            return 'URL is required';
+                        }
+                        try {
+                            new URL(value);
+                            return null;
+                        } catch {
+                            return 'Please enter a valid URL';
+                        }
+                    },
+                });
+
+                if (!inputUrl) {
+                    return;
+                }
+
+                baseUrl = inputUrl.trim();
+
+                await config.update('baseUrl', baseUrl, vscode.ConfigurationTarget.Global);
+                this.apiService.setBaseUrl(baseUrl);
+            }
+
             return;
         }
 
@@ -110,19 +140,20 @@ export class AuthService {
             await this.login(userId.trim(), password);
 
             vscode.window.showInformationMessage('Successfully logged in to Submitty');
-        } catch (error: any) {
-            vscode.window.showErrorMessage(`Login failed: ${error.message}`);
+        } catch (error: unknown) {
+            const err = error instanceof Error ? error.message : String(error);
+            vscode.window.showErrorMessage(`Login failed: ${err}`);
             throw error;
         }
     }
 
     // store token
-    private async storeToken(token: string) {
+    private async storeToken(token: string): Promise<void> {
         await keytar.setPassword('submittyToken', 'submittyToken', token);
     }
 
     // get token
-    private async getToken() {
+    private async getToken(): Promise<string | null> {
         return await keytar.getPassword('submittyToken', 'submittyToken');
     }
 
@@ -135,7 +166,7 @@ export class AuthService {
         const token = await this.apiService.login(userId, password);
         this.apiService.setAuthorizationToken(token);
         // store token in system keychain
-        this.storeToken(token);
+        await this.storeToken(token);
         return token;
     }