refactor: replace FastIndex caching with Map and add round-robin target selection

- Replace cafe-utility FastIndex with native Map for response caching
- Add round-robin load balancing for healthy targets
- Improve error handling in fetchWithTimeout with proper JSON validation
- Add markTargetAsUnhealthy function for better target management

Author: rampall

src/index.ts

@@ -4,7 +4,7 @@ import { Arrays, Objects } from 'cafe-utility'
 import { IncomingMessage, ServerResponse, createServer } from 'http'
 import fetch from 'node-fetch'
 import { metrics } from './metrics'
-import { Target, getHealthyTarget } from './target'
+import { Target, getHealthyTarget, markTargetAsUnhealthy } from './target'
 import { RequestContext, ResponseContext } from './types'
 import { fetchWithTimeout, respondWithFetchPromise } from './utility'
 
@@ -21,10 +21,11 @@ function main() {
     const port = Arrays.getNumberArgument(process.argv, 'port', process.env, PORT_ENV) || DEFAULT_PORT
     const target = Arrays.getArgument(process.argv, 'target', process.env, TARGET_ENV) || DEFAULT_TARGET
     const expiry = Arrays.getNumberArgument(process.argv, 'expiry', process.env, EXPIRY_ENV) || DEFAULT_EXPIRY
-    const fastIndex = Objects.createFastIndex()
+    const cache = new Map<string, { promise: Promise<ResponseContext | null>, expiry: number }>()
     const targets: Target[] = target.split(',').map(x => ({
         url: x,
-        lastErrorAt: 0
+        lastErrorAt: 0,
+        lastUsedAt: 0
     }))
     const server = createServer(async (request: IncomingMessage, response: ServerResponse) => {
         request.on('error', error => {
@@ -37,12 +38,12 @@ function main() {
             for (let i = 0; i < targets.length; i++) {
                 const target = getHealthyTarget(targets)
                 try {
-                    await fetch(target.url, { timeout: 10_000 })
+                    await fetch(target.url)
                     response.statusCode = 200
                     response.end(`200 OK - ${metrics.requests} requests served`)
                     return
                 } catch (error) {
-                    target.lastErrorAt = Date.now()
+                    markTargetAsUnhealthy(targets, target.url)
                     console.error(error)
                 }
             }
@@ -69,17 +70,15 @@ function main() {
                     delete parsedBody.id
                     metrics.requests++
                     const key = `${target.url}_${JSON.stringify(parsedBody)}`
-                    const cachedPromise = Objects.getFromFastIndexWithExpiracy(
-                        fastIndex,
-                        key
-                    ) as Promise<ResponseContext>
+                    const cached = cache.get(key)
+                    const cachedPromise = cached && cached.expiry > Date.now() ? cached.promise : null
                     if (cachedPromise) {
                         process.stdout.write(`Cache hit: ${key}\n`)
                         const successful = await respondWithFetchPromise(id, response, cachedPromise)
                         if (successful) {
                             return
                         } else {
-                            target.lastErrorAt = Date.now()
+                            markTargetAsUnhealthy(targets, target.url)
                             continue
                         }
                     }
@@ -92,16 +91,16 @@ function main() {
                         headers: context.headers,
                         body: context.body
                     })
-                    Objects.pushToFastIndexWithExpiracy(fastIndex as any, key, responsePromise, expiry)
+                    cache.set(key, { promise: responsePromise, expiry: Date.now() + expiry })
                     const successful = await respondWithFetchPromise(id, response, responsePromise)
                     if (successful) {
                         return
                     } else {
-                        target.lastErrorAt = Date.now()
+                        markTargetAsUnhealthy(targets, target.url)
                         continue
                     }
                 } catch (error) {
-                    target.lastErrorAt = Date.now()
+                    markTargetAsUnhealthy(targets, target.url)
                     console.error(error)
                 }
             }

src/target.ts

@@ -3,10 +3,29 @@ import { Dates } from 'cafe-utility'
 export type Target = {
     url: string
     lastErrorAt: number
+    lastUsedAt: number
 }
 
+let lastUsedIndex = 0
+
 export function getHealthyTarget(targets: Target[]): Target {
     const healthyIfLastErrorIsBefore = Date.now() - Dates.hours(2)
     const healthyTargets = targets.filter(x => x.lastErrorAt < healthyIfLastErrorIsBefore)
-    return healthyTargets[0] || targets[0]
+
+    if (healthyTargets.length === 0) {
+        return targets[0] // Fallback to first target if none are healthy
+    }
+
+    // Round-robin selection among healthy targets
+    const selectedTarget = healthyTargets[lastUsedIndex % healthyTargets.length]
+    lastUsedIndex = (lastUsedIndex + 1) % healthyTargets.length
+
+    return selectedTarget
+}
+
+export function markTargetAsUnhealthy(targets: Target[], targetUrl: string): void {
+    const target = targets.find(t => t.url === targetUrl)
+    if (target) {
+        target.lastErrorAt = Date.now()
+    }
 }

src/utility.ts

@@ -25,15 +25,31 @@ export async function respondWithFetchPromise(
 }
 
 export async function fetchWithTimeout(url: string, options: RequestInit): Promise<ResponseContext | null> {
-    const response = fetch(url, { ...options, timeout: 10_000 })
-        .then(async x => ({
-            status: x.status,
-            headers: x.headers.raw(),
-            json: await x.json()
-        }))
-        .catch(error => {
-            console.error(error)
+    try {
+        const response = await fetch(url, { ...options, timeout: 10_000 })
+
+        // Check if response is ok (status 200-299)
+        if (!response.ok) {
+            console.error(`HTTP ${response.status} error from ${url}: ${response.statusText}`)
+            return null
+        }
+
+        // Try to parse JSON, but handle non-JSON responses gracefully
+        let jsonData
+        try {
+            jsonData = await response.json()
+        } catch (jsonError) {
+            console.error(`Invalid JSON response from ${url}: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`)
             return null
-        })
-    return response
+        }
+
+        return {
+            status: response.status,
+            headers: response.headers.raw(),
+            json: jsonData
+        }
+    } catch (error) {
+        console.error(`Fetch error from ${url}:`, error)
+        return null
+    }
 }