fix: preserve aggregate provider failure context (#163)

Author: atomantic

server/src/routes/provider.routes.ts

@@ -125,8 +125,18 @@ router.post('/:provider/check-session', async (req: Request, res: Response) => {
  * Check sessions for all enabled providers
  */
 router.post('/check-all-sessions', asyncHandler(async (_req: Request, res: Response) => {
-  const statuses = await providerService.checkAllSessions();
-  res.json({ success: true, data: statuses });
+  const summary = await providerService.checkAllSessions();
+  const failedProviders = Object.keys(summary.failures);
+  if (failedProviders.length > 0) {
+    res.status(503).json({
+      success: false,
+      error: `Failed to check ${failedProviders.length} provider session${failedProviders.length === 1 ? '' : 's'}`,
+      details: summary
+    });
+    return;
+  }
+
+  res.json({ success: true, data: summary.statuses });
 }));
 
 /**

server/src/services/provider.service.ts

@@ -8,6 +8,7 @@ import type {
   ProviderTreeInfo,
   ProviderOperation,
   ProviderOperationResult,
+  ProviderSessionCheckSummary,
   EnsureAuthResult
 } from '@fsf/shared';
 import { browserService, isFamilySearchAuthUrl } from './browser.service.js';
@@ -356,19 +357,21 @@ export const providerService = {
   /**
    * Check session status for all enabled providers
    */
-  async checkAllSessions(): Promise<Record<BuiltInProvider, ProviderSessionStatus>> {
-    const registry = loadRegistry();
-    const results: Record<BuiltInProvider, ProviderSessionStatus> = {} as Record<BuiltInProvider, ProviderSessionStatus>;
+  async checkAllSessions(): Promise<ProviderSessionCheckSummary> {
+    const registry = this.getAllConfigs();
+    const statuses: ProviderSessionCheckSummary['statuses'] = {};
+    const failures: ProviderSessionCheckSummary['failures'] = {};
 
     for (const provider of listProviders()) {
       if (registry.providers[provider].enabled) {
         const result = await this.checkSession(provider);
-        if (!result.success) {
-          throw new Error(result.error.message);
+        if (result.success) {
+          statuses[provider] = result.data;
+        } else {
+          failures[provider] = result.error;
         }
-        results[provider] = result.data;
       } else {
-        results[provider] = {
+        statuses[provider] = {
           provider,
           enabled: false,
           loggedIn: false,
@@ -377,7 +380,7 @@ export const providerService = {
       }
     }
 
-    return results;
+    return { statuses, failures };
   },
 
   /**

shared/src/index.ts

@@ -202,6 +202,11 @@ export type ProviderOperationResult<T> =
   | { success: true; data: T }
   | { success: false; error: ProviderOperationFailure };
 
+export interface ProviderSessionCheckSummary {
+  statuses: Partial<Record<BuiltInProvider, ProviderSessionStatus>>;
+  failures: Partial<Record<BuiltInProvider, ProviderOperationFailure>>;
+}
+
 // Auto-login method type
 export type AutoLoginMethod = 'credentials' | 'google';
 

tests/integration/api/providers.spec.ts

@@ -5,6 +5,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 const mocks = vi.hoisted(() => ({
   providerService: {
     checkSession: vi.fn(),
+    checkAllSessions: vi.fn(),
     discoverTrees: vi.fn(),
   },
 }));
@@ -89,6 +90,47 @@ describe('Provider routes', () => {
     });
   });
 
+  it('returns successful statuses and structured failures from aggregate checks', async () => {
+    mocks.providerService.checkAllSessions.mockResolvedValue({
+      statuses: {
+        ancestry: {
+          provider: 'ancestry',
+          enabled: true,
+          loggedIn: true,
+        },
+      },
+      failures: {
+        familysearch: failure('check-session', 'CDP refused connection').error,
+      },
+    });
+
+    const response = await request(app)
+      .post('/api/scrape-providers/check-all-sessions')
+      .expect(503);
+
+    expect(response.body).toEqual({
+      success: false,
+      error: 'Failed to check 1 provider session',
+      details: {
+        statuses: {
+          ancestry: {
+            provider: 'ancestry',
+            enabled: true,
+            loggedIn: true,
+          },
+        },
+        failures: {
+          familysearch: {
+            code: 'PROVIDER_OPERATION_FAILED',
+            provider: 'familysearch',
+            operation: 'check-session',
+            message: 'CDP refused connection',
+          },
+        },
+      },
+    });
+  });
+
   it('returns an empty tree list only when discovery succeeded', async () => {
     mocks.providerService.discoverTrees.mockResolvedValue({ success: true, data: [] });
 

tests/unit/services/providerService.spec.ts

@@ -50,6 +50,18 @@ describe('providerService operational failures', () => {
       browserScrapeEnabled: true,
       browserLoggedIn: false,
     });
+    vi.spyOn(providerService, 'getAllConfigs').mockReturnValue({
+      providers: {
+        familysearch: {
+          provider: 'familysearch',
+          enabled: true,
+          rateLimit: { minDelayMs: 1000, maxDelayMs: 2000 },
+          browserScrapeEnabled: true,
+          browserLoggedIn: false,
+        },
+      },
+      lastUpdated: '2026-08-30T00:00:00.000Z',
+    } as ReturnType<typeof providerService.getAllConfigs>);
     mocks.browserService.isConnected.mockReturnValue(true);
     mocks.browserService.getWorkerPage.mockResolvedValue({});
     mocks.scraper.checkLoginStatus.mockResolvedValue(false);
@@ -111,6 +123,22 @@ describe('providerService operational failures', () => {
     );
   });
 
+  it('preserves successful statuses and structured failures in aggregate checks', async () => {
+    mocks.scraper.checkLoginStatus.mockRejectedValue(new Error('Login markup changed'));
+
+    const summary = await providerService.checkAllSessions();
+
+    expect(summary.statuses).toEqual({});
+    expect(summary.failures).toEqual({
+      familysearch: {
+        code: 'PROVIDER_OPERATION_FAILED',
+        provider: 'familysearch',
+        operation: 'check-session',
+        message: 'Login markup changed',
+      },
+    });
+  });
+
   it('keeps a verified empty tree list as a successful negative result', async () => {
     const result = await providerService.discoverTrees('familysearch');