feat(core): return RefreshResult from ContextBridge.refresh()

Surfaces provider errors through RefreshResult.errors instead of
silently ignoring them.

Co-authored-by: Ona <no-reply@ona.com>

packages/aris-core/README.md

@@ -107,7 +107,7 @@ class LocationProvider implements ContextProvider<Location> {
 		return () => navigator.geolocation.clearWatch(watchId)
 	}
 
-	async getCurrentValue(): Promise<Location> {
+	async fetchCurrentValue(): Promise<Location> {
 		const pos = await new Promise<GeolocationPosition>((resolve, reject) => {
 			navigator.geolocation.getCurrentPosition(resolve, reject)
 		})

packages/aris-core/src/context-bridge.ts

@@ -5,6 +5,15 @@ interface ContextUpdatable {
 	pushContextUpdate(update: Partial<Context>): void
 }
 
+export interface ProviderError {
+	key: string
+	error: Error
+}
+
+export interface RefreshResult {
+	errors: ProviderError[]
+}
+
 /**
  * Bridges context providers to a feed controller.
  *
@@ -55,18 +64,32 @@ export class ContextBridge {
 	/**
 	 * Gathers current values from all providers and pushes to controller.
 	 * Use for manual refresh when user pulls to refresh.
+	 * Returns errors from providers that failed to fetch.
 	 */
-	async refresh(): Promise<void> {
+	async refresh(): Promise<RefreshResult> {
 		const updates: Partial<Context> = {}
+		const errors: ProviderError[] = []
 
 		const entries = Array.from(this.providers.entries())
-		const values = await Promise.all(entries.map(([_, provider]) => provider.getCurrentValue()))
+		const results = await Promise.allSettled(
+			entries.map(([_, provider]) => provider.fetchCurrentValue()),
+		)
 
 		entries.forEach(([key], i) => {
-			updates[key] = values[i]
+			const result = results[i]
+			if (result?.status === "fulfilled") {
+				updates[key] = result.value
+			} else if (result?.status === "rejected") {
+				errors.push({
+					key,
+					error: result.reason instanceof Error ? result.reason : new Error(String(result.reason)),
+				})
+			}
 		})
 
 		this.controller.pushContextUpdate(updates)
+
+		return { errors }
 	}
 
 	/**

packages/aris-core/src/context-provider.ts

@@ -16,7 +16,7 @@
  *     return () => navigator.geolocation.clearWatch(watchId)
  *   }
  *
- *   async getCurrentValue(): Promise<Location> {
+ *   async fetchCurrentValue(): Promise<Location> {
  *     const pos = await getCurrentPosition()
  *     return { lat: pos.coords.latitude, lng: pos.coords.longitude, accuracy: pos.coords.accuracy }
  *   }
@@ -30,6 +30,6 @@ export interface ContextProvider<T = unknown> {
 	/** Subscribe to value changes. Returns cleanup function. */
 	onUpdate(callback: (value: T) => void): () => void
 
-	/** Get current value on-demand (used for manual refresh). */
-	getCurrentValue(): Promise<T>
+	/** Fetch current value on-demand (used for manual refresh). */
+	fetchCurrentValue(): Promise<T>
 }

packages/aris-core/src/index.ts

@@ -12,6 +12,7 @@ export type { DataSource } from "./data-source"
 export type { ContextProvider } from "./context-provider"
 
 // Context Bridge
+export type { ProviderError, RefreshResult } from "./context-bridge"
 export { ContextBridge } from "./context-bridge"
 
 // Reconciler

packages/aris-core/src/integration.test.ts

@@ -111,7 +111,7 @@ function createLocationProvider(): SimulatedLocationProvider {
 				callback = null
 			}
 		},
-		async getCurrentValue() {
+		async fetchCurrentValue() {
 			return currentLocation
 		},
 		simulateUpdate(location: Location) {

packages/aris-data-source-tfl/src/data-source.ts

@@ -1,5 +1,5 @@
 import type { Context, DataSource } from "@aris/core"
-import { TflApi, type ITflApi } from "./tfl-api.ts"
+
 import type {
 	StationLocation,
 	TflAlertData,
@@ -10,6 +10,8 @@ import type {
 	TflLineId,
 } from "./types.ts"
 
+import { TflApi, type ITflApi } from "./tfl-api.ts"
+
 const SEVERITY_PRIORITY: Record<TflAlertSeverity, number> = {
 	closure: 100,
 	"major-delays": 80,
@@ -22,7 +24,10 @@ function haversineDistance(lat1: number, lng1: number, lat2: number, lng2: numbe
 	const dLng = ((lng2 - lng1) * Math.PI) / 180
 	const a =
 		Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-		Math.cos((lat1 * Math.PI) / 180) * Math.cos((lat2 * Math.PI) / 180) * Math.sin(dLng / 2) * Math.sin(dLng / 2)
+		Math.cos((lat1 * Math.PI) / 180) *
+			Math.cos((lat2 * Math.PI) / 180) *
+			Math.sin(dLng / 2) *
+			Math.sin(dLng / 2)
 	const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
 	return R * c
 }
@@ -62,13 +67,20 @@ export class TflDataSource implements DataSource<TflAlertFeedItem, TflDataSource
 	}
 
 	async query(context: Context, config: TflDataSourceConfig): Promise<TflAlertFeedItem[]> {
-		const [statuses, stations] = await Promise.all([this.api.fetchLineStatuses(config.lines), this.api.fetchStations()])
+		const [statuses, stations] = await Promise.all([
+			this.api.fetchLineStatuses(config.lines),
+			this.api.fetchStations(),
+		])
 
 		const items: TflAlertFeedItem[] = statuses.map((status) => {
-			const closestStationDistance =
-				context.location ?
-					findClosestStationDistance(status.lineId, stations, context.location.lat, context.location.lng)
-				:	null
+			const closestStationDistance = context.location
+				? findClosestStationDistance(
+						status.lineId,
+						stations,
+						context.location.lat,
+						context.location.lng,
+					)
+				: null
 
 			const data: TflAlertData = {
 				line: status.lineId,

packages/aris-data-source-tfl/src/integration.test.ts

@@ -1,11 +1,12 @@
+import type { Context } from "@aris/core"
+
 import { describe, expect, test } from "bun:test"
 
-import type { Context } from "@aris/core"
-import { TflDataSource } from "./data-source.ts"
 import type { ITflApi, TflLineStatus } from "./tfl-api.ts"
 import type { StationLocation, TflLineId } from "./types.ts"
 
 import fixtures from "../fixtures/tfl-responses.json"
+import { TflDataSource } from "./data-source.ts"
 
 // Mock API that returns fixture data
 class FixtureTflApi implements ITflApi {
@@ -109,9 +110,10 @@ describe("TfL Feed Items (using fixture data)", () => {
 			expect(typeof item.data.lineName).toBe("string")
 			expect(["minor-delays", "major-delays", "closure"]).toContain(item.data.severity)
 			expect(typeof item.data.description).toBe("string")
-			expect(item.data.closestStationDistance === null || typeof item.data.closestStationDistance === "number").toBe(
-				true,
-			)
+			expect(
+				item.data.closestStationDistance === null ||
+					typeof item.data.closestStationDistance === "number",
+			).toBe(true)
 		}
 	})
 

packages/aris-data-source-tfl/src/tfl-api.ts

@@ -1,4 +1,5 @@
 import { type } from "arktype"
+
 import type { StationLocation, TflAlertSeverity } from "./types.ts"
 
 const TFL_API_BASE = "https://api.tfl.gov.uk"

packages/aris-data-source-tfl/src/types.ts

@@ -1,4 +1,5 @@
 import type { FeedItem } from "@aris/core"
+
 import type { TflLineId } from "./tfl-api.ts"
 
 export type { TflLineId } from "./tfl-api.ts"