@stacksjs/bun-router 0.0.5 → 0.0.6

package/src/session/file-store.ts

@@ -0,0 +1,148 @@
+import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import type { SessionData, SessionStore } from '../types/core'
+
+interface FileSession {
+  data: SessionData
+  expiresAt: number
+}
+
+/**
+ * File-based session store.
+ * Persists sessions to disk as JSON files.
+ * Suitable for single-server deployments.
+ */
+export class FileSessionStore implements SessionStore<SessionData> {
+  private dir: string
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null
+
+  constructor(
+    private defaultTtl: number = 86400,
+    dir?: string,
+  ) {
+    this.dir = dir || join(tmpdir(), 'bun-router-sessions')
+    if (!existsSync(this.dir)) {
+      mkdirSync(this.dir, { recursive: true })
+    }
+
+    // Cleanup every 10 minutes
+    this.cleanupInterval = setInterval(() => this.cleanup(), 10 * 60 * 1000)
+  }
+
+  private filePath(sid: string): string {
+    // Sanitize session ID to prevent path traversal
+    const safeSid = sid.replace(/[^a-zA-Z0-9_-]/g, '')
+    return join(this.dir, `${safeSid}.json`)
+  }
+
+  async get(sid: string): Promise<SessionData | null> {
+    const path = this.filePath(sid)
+    if (!existsSync(path)) return null
+
+    try {
+      const content = readFileSync(path, 'utf-8')
+      const stored: FileSession = JSON.parse(content)
+
+      if (Date.now() > stored.expiresAt) {
+        unlinkSync(path)
+        return null
+      }
+
+      return stored.data
+    }
+    catch {
+      return null
+    }
+  }
+
+  async set(sid: string, session: SessionData, ttl?: number): Promise<void> {
+    const stored: FileSession = {
+      data: session,
+      expiresAt: Date.now() + (ttl ?? this.defaultTtl) * 1000,
+    }
+
+    writeFileSync(this.filePath(sid), JSON.stringify(stored), 'utf-8')
+  }
+
+  async destroy(sid: string): Promise<void> {
+    const path = this.filePath(sid)
+    if (existsSync(path)) {
+      unlinkSync(path)
+    }
+  }
+
+  async touch(sid: string, session: SessionData, ttl?: number): Promise<void> {
+    const path = this.filePath(sid)
+    if (!existsSync(path)) return
+
+    const stored: FileSession = {
+      data: session,
+      expiresAt: Date.now() + (ttl ?? this.defaultTtl) * 1000,
+    }
+
+    writeFileSync(path, JSON.stringify(stored), 'utf-8')
+  }
+
+  async all(): Promise<Record<string, SessionData>> {
+    const result: Record<string, SessionData> = {}
+    const now = Date.now()
+
+    try {
+      const files = readdirSync(this.dir).filter(f => f.endsWith('.json'))
+      for (const file of files) {
+        const content = readFileSync(join(this.dir, file), 'utf-8')
+        const stored: FileSession = JSON.parse(content)
+        if (now <= stored.expiresAt) {
+          const sid = file.replace('.json', '')
+          result[sid] = stored.data
+        }
+      }
+    }
+    catch { /* ignore errors */ }
+
+    return result
+  }
+
+  async length(): Promise<number> {
+    try {
+      return readdirSync(this.dir).filter(f => f.endsWith('.json')).length
+    }
+    catch {
+      return 0
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      const files = readdirSync(this.dir).filter(f => f.endsWith('.json'))
+      for (const file of files) {
+        unlinkSync(join(this.dir, file))
+      }
+    }
+    catch { /* ignore errors */ }
+  }
+
+  private cleanup(): void {
+    const now = Date.now()
+    try {
+      const files = readdirSync(this.dir).filter(f => f.endsWith('.json'))
+      for (const file of files) {
+        const path = join(this.dir, file)
+        const content = readFileSync(path, 'utf-8')
+        const stored: FileSession = JSON.parse(content)
+        if (now > stored.expiresAt) {
+          unlinkSync(path)
+        }
+      }
+    }
+    catch { /* ignore errors */ }
+  }
+
+  dispose(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval)
+      this.cleanupInterval = null
+    }
+  }
+}

package/src/session/index.ts

@@ -0,0 +1,244 @@
+import type { SessionData, SessionStore } from '../types/core'
+import { MemorySessionStore } from './memory-store'
+import { FileSessionStore } from './file-store'
+import { RedisSessionStore } from './redis-store'
+import type { RedisClient } from './redis-store'
+import { DatabaseSessionStore } from './database-store'
+import type { SessionDatabaseAdapter } from './database-store'
+
+export { MemorySessionStore } from './memory-store'
+export { FileSessionStore } from './file-store'
+export { RedisSessionStore } from './redis-store'
+export type { RedisClient } from './redis-store'
+export { DatabaseSessionStore } from './database-store'
+export type { SessionDatabaseAdapter } from './database-store'
+
+export interface SessionConfig {
+  driver: 'memory' | 'file' | 'redis' | 'database'
+  ttl?: number
+  cookie?: {
+    name?: string
+    maxAge?: number
+    path?: string
+    httpOnly?: boolean
+    secure?: boolean
+    sameSite?: 'strict' | 'lax' | 'none'
+  }
+  // Driver-specific options
+  file?: {
+    dir?: string
+  }
+  redis?: {
+    client: RedisClient
+    prefix?: string
+  }
+  database?: {
+    adapter: SessionDatabaseAdapter
+  }
+}
+
+/**
+ * Create a session store based on configuration
+ */
+export function createSessionStore(config: SessionConfig): SessionStore<SessionData> {
+  const ttl = config.ttl ?? 86400
+
+  switch (config.driver) {
+    case 'memory':
+      return new MemorySessionStore(ttl)
+
+    case 'file':
+      return new FileSessionStore(ttl, config.file?.dir)
+
+    case 'redis': {
+      if (!config.redis?.client) {
+        throw new Error('Redis client is required for redis session driver')
+      }
+      return new RedisSessionStore(config.redis.client, ttl, config.redis.prefix)
+    }
+
+    case 'database': {
+      if (!config.database?.adapter) {
+        throw new Error('Database adapter is required for database session driver')
+      }
+      return new DatabaseSessionStore(config.database.adapter, ttl)
+    }
+
+    default:
+      return new MemorySessionStore(ttl)
+  }
+}
+
+/**
+ * Session manager for request handling.
+ * Wraps a SessionStore and provides flash data, regeneration, etc.
+ */
+export class SessionManager {
+  private sessionId: string
+  private data: SessionData
+  private store: SessionStore<SessionData>
+  private flashedKeys: string[] = []
+  private previousFlash: Record<string, unknown> = {}
+  private dirty = false
+
+  constructor(sessionId: string, data: SessionData, store: SessionStore<SessionData>) {
+    this.sessionId = sessionId
+    this.data = data
+    this.store = store
+
+    // Capture previous flash data to clear after this request
+    this.previousFlash = { ...(data.flash || {}) }
+  }
+
+  get id(): string {
+    return this.sessionId
+  }
+
+  /**
+   * Get a value from the session
+   */
+  get<T = unknown>(key: string): T | undefined {
+    // Check flash data first
+    if (this.data.flash && key in this.data.flash) {
+      return this.data.flash[key] as T
+    }
+    if (this.data.data && key in this.data.data) {
+      return this.data.data[key] as T
+    }
+    return undefined
+  }
+
+  /**
+   * Set a value in the session
+   */
+  set(key: string, value: unknown): void {
+    if (!this.data.data) this.data.data = {}
+    this.data.data[key] = value
+    this.dirty = true
+  }
+
+  /**
+   * Check if a key exists in the session
+   */
+  has(key: string): boolean {
+    return (this.data.data && key in this.data.data) || (this.data.flash && key in this.data.flash) || false
+  }
+
+  /**
+   * Remove a value from the session
+   */
+  forget(key: string): void {
+    if (this.data.data) {
+      delete this.data.data[key]
+      this.dirty = true
+    }
+  }
+
+  /**
+   * Get all session data
+   */
+  all(): Record<string, unknown> {
+    return { ...(this.data.data || {}), ...(this.data.flash || {}) }
+  }
+
+  /**
+   * Flash a key-value pair for the next request only
+   */
+  flash(key: string, value: unknown): void {
+    if (!this.data.flash) this.data.flash = {}
+    this.data.flash[key] = value
+    this.flashedKeys.push(key)
+    this.dirty = true
+  }
+
+  /**
+   * Get a flash value (available for current request)
+   */
+  getFlash<T = unknown>(key: string): T | undefined {
+    return this.previousFlash[key] as T | undefined
+  }
+
+  /**
+   * Keep specific flash data for another request
+   */
+  keep(keys: string[]): void {
+    for (const key of keys) {
+      if (key in this.previousFlash) {
+        this.flash(key, this.previousFlash[key])
+      }
+    }
+  }
+
+  /**
+   * Reflash all flash data for another request
+   */
+  reflash(): void {
+    for (const [key, value] of Object.entries(this.previousFlash)) {
+      this.flash(key, value)
+    }
+  }
+
+  /**
+   * Regenerate session ID (keeps data)
+   */
+  async regenerate(): Promise<string> {
+    const oldId = this.sessionId
+    this.sessionId = generateSessionId()
+
+    // Move data to new session
+    await this.store.set(this.sessionId, this.data)
+    await this.store.destroy(oldId)
+
+    return this.sessionId
+  }
+
+  /**
+   * Invalidate the session (new ID, clear data)
+   */
+  async invalidate(): Promise<string> {
+    const oldId = this.sessionId
+    this.sessionId = generateSessionId()
+    this.data = { id: this.sessionId }
+
+    await this.store.destroy(oldId)
+    await this.store.set(this.sessionId, this.data)
+
+    return this.sessionId
+  }
+
+  /**
+   * Save session data to the store.
+   * Call this at the end of the request.
+   */
+  async save(): Promise<void> {
+    // Clear old flash data (data that was available this request but not re-flashed)
+    if (this.data.flash) {
+      const newFlash: Record<string, unknown> = {}
+      for (const key of this.flashedKeys) {
+        if (this.data.flash[key] !== undefined) {
+          newFlash[key] = this.data.flash[key]
+        }
+      }
+      this.data.flash = Object.keys(newFlash).length > 0 ? newFlash : undefined
+    }
+
+    await this.store.set(this.sessionId, this.data)
+  }
+
+  /**
+   * Destroy the session completely
+   */
+  async destroy(): Promise<void> {
+    await this.store.destroy(this.sessionId)
+    this.data = {}
+  }
+}
+
+/**
+ * Generate a cryptographically secure session ID
+ */
+export function generateSessionId(): string {
+  const bytes = new Uint8Array(32)
+  crypto.getRandomValues(bytes)
+  return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('')
+}

package/src/session/memory-store.ts

@@ -0,0 +1,88 @@
+import type { SessionData, SessionStore } from '../types/core'
+
+interface StoredSession {
+  data: SessionData
+  expiresAt: number
+}
+
+/**
+ * In-memory session store.
+ * Fast but data is lost on server restart.
+ * Suitable for development or single-process deployments.
+ */
+export class MemorySessionStore implements SessionStore<SessionData> {
+  private sessions = new Map<string, StoredSession>()
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null
+
+  constructor(private defaultTtl: number = 86400) {
+    // Run cleanup every 5 minutes
+    this.cleanupInterval = setInterval(() => this.cleanup(), 5 * 60 * 1000)
+  }
+
+  async get(sid: string): Promise<SessionData | null> {
+    const stored = this.sessions.get(sid)
+    if (!stored) return null
+
+    if (Date.now() > stored.expiresAt) {
+      this.sessions.delete(sid)
+      return null
+    }
+
+    return stored.data
+  }
+
+  async set(sid: string, session: SessionData, ttl?: number): Promise<void> {
+    const expiresAt = Date.now() + (ttl ?? this.defaultTtl) * 1000
+    this.sessions.set(sid, { data: session, expiresAt })
+  }
+
+  async destroy(sid: string): Promise<void> {
+    this.sessions.delete(sid)
+  }
+
+  async touch(sid: string, session: SessionData, ttl?: number): Promise<void> {
+    const stored = this.sessions.get(sid)
+    if (stored) {
+      stored.expiresAt = Date.now() + (ttl ?? this.defaultTtl) * 1000
+      stored.data = session
+    }
+  }
+
+  async all(): Promise<Record<string, SessionData>> {
+    const result: Record<string, SessionData> = {}
+    const now = Date.now()
+
+    for (const [sid, stored] of this.sessions) {
+      if (now <= stored.expiresAt) {
+        result[sid] = stored.data
+      }
+    }
+
+    return result
+  }
+
+  async length(): Promise<number> {
+    return this.sessions.size
+  }
+
+  async clear(): Promise<void> {
+    this.sessions.clear()
+  }
+
+  private cleanup(): void {
+    const now = Date.now()
+    for (const [sid, stored] of this.sessions) {
+      if (now > stored.expiresAt) {
+        this.sessions.delete(sid)
+      }
+    }
+  }
+
+  dispose(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval)
+      this.cleanupInterval = null
+    }
+    this.sessions.clear()
+  }
+}

package/src/session/redis-store.ts

@@ -0,0 +1,93 @@
+import type { SessionData, SessionStore } from '../types/core'
+
+/**
+ * Minimal Redis client interface.
+ * Compatible with ioredis, node-redis, or any client implementing these methods.
+ */
+export interface RedisClient {
+  get(key: string): Promise<string | null>
+  set(key: string, value: string, ...args: any[]): Promise<any>
+  del(key: string | string[]): Promise<number>
+  expire(key: string, seconds: number): Promise<number>
+  keys(pattern: string): Promise<string[]>
+}
+
+/**
+ * Redis-backed session store.
+ * Ideal for distributed/multi-server deployments.
+ * Requires a Redis client to be passed in.
+ */
+export class RedisSessionStore implements SessionStore<SessionData> {
+  private prefix: string
+
+  constructor(
+    private client: RedisClient,
+    private defaultTtl: number = 86400,
+    prefix: string = 'sess:',
+  ) {
+    this.prefix = prefix
+  }
+
+  private key(sid: string): string {
+    return `${this.prefix}${sid}`
+  }
+
+  async get(sid: string): Promise<SessionData | null> {
+    const data = await this.client.get(this.key(sid))
+    if (!data) return null
+
+    try {
+      return JSON.parse(data) as SessionData
+    }
+    catch {
+      return null
+    }
+  }
+
+  async set(sid: string, session: SessionData, ttl?: number): Promise<void> {
+    const key = this.key(sid)
+    const seconds = ttl ?? this.defaultTtl
+    await this.client.set(key, JSON.stringify(session), 'EX', seconds)
+  }
+
+  async destroy(sid: string): Promise<void> {
+    await this.client.del(this.key(sid))
+  }
+
+  async touch(sid: string, session: SessionData, ttl?: number): Promise<void> {
+    const key = this.key(sid)
+    const seconds = ttl ?? this.defaultTtl
+    // Reset TTL and update data
+    await this.client.set(key, JSON.stringify(session), 'EX', seconds)
+  }
+
+  async all(): Promise<Record<string, SessionData>> {
+    const keys = await this.client.keys(`${this.prefix}*`)
+    const result: Record<string, SessionData> = {}
+
+    for (const key of keys) {
+      const data = await this.client.get(key)
+      if (data) {
+        try {
+          const sid = key.slice(this.prefix.length)
+          result[sid] = JSON.parse(data)
+        }
+        catch { /* skip invalid data */ }
+      }
+    }
+
+    return result
+  }
+
+  async length(): Promise<number> {
+    const keys = await this.client.keys(`${this.prefix}*`)
+    return keys.length
+  }
+
+  async clear(): Promise<void> {
+    const keys = await this.client.keys(`${this.prefix}*`)
+    if (keys.length > 0) {
+      await this.client.del(keys)
+    }
+  }
+}

package/src/streaming/index.ts

@@ -0,0 +1,17 @@
+export type { SSEConfig, SSEEvent } from '../types'
+
+export {
+  createSSEMiddleware,
+  SSEConnectionManager,
+  SSEHandler,
+  sseManager,
+  SSEUtils,
+} from './sse-handler'
+
+export {
+  type BaseStreamConfig,
+  FileStreamHandler,
+  StreamHandler,
+  StreamResponse,
+  StreamUtils,
+} from './stream-handler'