@thoughtpivot/flight 2.0.1 → 3.0.0

package/src/bun/store.ts

@@ -0,0 +1,128 @@
+/** Key/value store shared by sessions and the response cache. */
+export interface KVStore {
+    get(key: string): Promise<string | null>
+    set(key: string, value: string, ttlSec: number): Promise<void>
+    del(key: string): Promise<void>
+}
+
+/**
+ * In-process store used when Redis is unset or unreachable.
+ */
+class MemoryStore implements KVStore {
+    private entries = new Map<string, { value: string; exp: number }>()
+
+    /** Read a value, dropping it when the TTL has passed. */
+    async get(key: string): Promise<string | null> {
+        const entry = this.entries.get(key)
+        if (!entry) return null
+        if (entry.exp && entry.exp < Date.now()) {
+            this.entries.delete(key)
+            return null
+        }
+        return entry.value
+    }
+
+    /** Store a value. A non-positive TTL means no expiry. */
+    async set(key: string, value: string, ttlSec: number): Promise<void> {
+        this.entries.set(key, { value, exp: ttlSec > 0 ? Date.now() + ttlSec * 1000 : 0 })
+    }
+
+    /** Remove a key. */
+    async del(key: string): Promise<void> {
+        this.entries.delete(key)
+    }
+}
+
+/**
+ * Bun's built-in Redis client. Typed loosely because the surface varies by Bun version.
+ */
+class RedisStore implements KVStore {
+    constructor(private client: any) {}
+
+    /** Read a Redis string. */
+    async get(key: string): Promise<string | null> {
+        return await this.client.get(key)
+    }
+
+    /** Write a Redis string with an optional EX expiry. */
+    async set(key: string, value: string, ttlSec: number): Promise<void> {
+        if (ttlSec > 0) await this.client.send('SET', [key, value, 'EX', String(ttlSec)])
+        else await this.client.set(key, value)
+    }
+
+    /** Delete a Redis key. */
+    async del(key: string): Promise<void> {
+        await this.client.del(key)
+    }
+}
+
+/**
+ * Use Redis until a command fails, then stay on the in-memory store.
+ */
+class FallbackStore implements KVStore {
+    private degraded = false
+
+    constructor(
+        private primary: KVStore,
+        private fallback: KVStore,
+        private label: string
+    ) {}
+
+    /** Log the first Redis failure and switch to memory. */
+    private trip(err: unknown) {
+        if (this.degraded) return
+        this.degraded = true
+        const message = err instanceof Error ? err.message : String(err)
+        console.warn(`flight-bun: ${this.label} store degraded to in-memory (Redis error): ${message}`)
+    }
+
+    /** Read from Redis, or from memory after a failure. */
+    async get(key: string): Promise<string | null> {
+        if (this.degraded) return this.fallback.get(key)
+        try {
+            return await this.primary.get(key)
+        } catch (err) {
+            this.trip(err)
+            return this.fallback.get(key)
+        }
+    }
+
+    /** Write to Redis, or to memory after a failure. */
+    async set(key: string, value: string, ttlSec: number): Promise<void> {
+        if (this.degraded) return this.fallback.set(key, value, ttlSec)
+        try {
+            await this.primary.set(key, value, ttlSec)
+        } catch (err) {
+            this.trip(err)
+            await this.fallback.set(key, value, ttlSec)
+        }
+    }
+
+    /** Delete from Redis, or from memory after a failure. */
+    async del(key: string): Promise<void> {
+        if (this.degraded) return this.fallback.del(key)
+        try {
+            await this.primary.del(key)
+        } catch (err) {
+            this.trip(err)
+            await this.fallback.del(key)
+        }
+    }
+}
+
+/**
+ * Redis when `FLIGHT_REDIS_URL` is set, otherwise memory.
+ * A down Redis degrades the request instead of failing it.
+ */
+export function createStore(redisUrl: string | undefined, label: string): KVStore {
+    const memory = new MemoryStore()
+    if (!redisUrl) return memory
+    try {
+        const client = new Bun.RedisClient(redisUrl)
+        return new FallbackStore(new RedisStore(client), memory, label)
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err)
+        console.warn(`flight-bun: ${label} store could not init Redis, using in-memory: ${message}`)
+        return memory
+    }
+}

package/src/flight.ts

@@ -21,6 +21,7 @@ import ratelimit from 'koa-ratelimit'
 import serve from 'koa-static'
 import session from 'koa-session'
 
+import { backendDiscoveryIgnorePatterns, dedupeStrings, mergeExcludePaths } from './backend-discovery.js'
 import {
     applyTrustProxy,
     httpCacheEnabledInSpaPipeline,
@@ -45,45 +46,6 @@ interface FlightArgv {
     exclude_paths?: string[]
 }
 
-function normalizeExcludePaths(value: unknown): string[] {
-    if (value == null || value === '') return []
-    const parts = Array.isArray(value) ? value : [value]
-    const out: string[] = []
-    for (const p of parts) {
-        const s = String(p).trim()
-        if (!s) continue
-        out.push(
-            ...s
-                .split(',')
-                .map((x) => x.trim())
-                .filter(Boolean)
-        )
-    }
-    return out
-}
-
-function dedupeStrings(items: string[]): string[] {
-    return [...new Set(items)]
-}
-
-/** Build fast-glob ignore globs for trees rooted under `appRootAbs`. */
-function backendDiscoveryIgnorePatterns(appRootAbs: string, excludeRelativeDirs: string[]): string[] {
-    const patterns: string[] = []
-    for (const raw of excludeRelativeDirs) {
-        const trimmed = raw.trim()
-        if (!trimmed) continue
-        const resolved = path.resolve(appRootAbs, trimmed)
-        const rel = path.relative(appRootAbs, resolved)
-        const relPosix = rel.replace(/\\/g, '/')
-        if (!relPosix || relPosix.startsWith('..') || path.isAbsolute(rel)) {
-            console.warn(`Flight: exclude_paths entry skipped (outside app_home): ${trimmed}`)
-            continue
-        }
-        patterns.push(`${relPosix}/**`)
-    }
-    return patterns
-}
-
 // tsx (and similar loaders) may expose require('yargs/yargs') as { default: factory } instead of factory.
 interface YargsInstance {
     option(key: string, opts: Record<string, unknown>): YargsInstance
@@ -102,7 +64,7 @@ const argv = yargsEntry(process.argv.slice(2))
     })
     .option('mode', {
         type: 'string',
-        describe: 'development (Vite HMR) or production'
+        describe: 'development (Vite HMR for Vue/React per vite.config) or production'
     })
     .option('port', {
         type: 'number',
@@ -188,10 +150,7 @@ if (argv.disable_vite === undefined) {
 argv.disable_vite = Boolean(argv.disable_vite)
 
 const appHomePath = path.resolve(argv.app_home)
-const excludePathsConfigured = dedupeStrings([
-    ...normalizeExcludePaths(argv.exclude_paths),
-    ...normalizeExcludePaths(process.env.FLIGHT_EXCLUDE_PATHS)
-])
+const excludePathsConfigured = mergeExcludePaths(argv.exclude_paths, process.env.FLIGHT_EXCLUDE_PATHS)
 const backendDiscoveryIgnores = backendDiscoveryIgnorePatterns(appHomePath, excludePathsConfigured)
 
 process.chdir(appHomePath)
@@ -359,12 +318,12 @@ if (cluster.isPrimary) {
         })
 
         viteProcess.on('error', (error) => {
-            console.error('Failed to start vite server:', error)
+            console.error('Failed to start Vite dev server:', error)
         })
 
         viteProcess.on('exit', (code) => {
             if (code !== 0) {
-                console.error(`Vite server exited with code ${code}`)
+                console.error(`Vite dev server exited with code ${code}`)
             }
         })
 
@@ -373,6 +332,6 @@ if (cluster.isPrimary) {
             process.exit(0)
         })
 
-        console.log(`Vite development server with hot module reload ${process.pid} started on 3001`)
+        console.log(`Vite dev server (HMR for Vue/React per your vite.config) for worker ${process.pid} on port 3001`)
     }
 }