@stacksjs/bun-router 0.0.12 → 0.0.14

package/src/session/file-store.ts

@@ -1,148 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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'