@stacksjs/bun-router 0.0.4 → 0.0.6

package/src/routing/subdomain-routing.ts

@@ -0,0 +1,492 @@
+import type { EnhancedRequest, MiddlewareHandler, RouteHandler } from '../types'
+
+/**
+ * Domain pattern configuration
+ */
+export interface DomainPattern {
+  pattern: string // e.g., '{account}.app.com', 'api.{domain}.com'
+  parameters: string[] // Extracted parameter names
+  regex: RegExp // Compiled regex for matching
+}
+
+/**
+ * Domain group configuration
+ */
+export interface DomainGroupConfig {
+  domain: string
+  middleware?: MiddlewareHandler[]
+  prefix?: string
+  name?: string
+}
+
+/**
+ * Subdomain route information
+ */
+export interface SubdomainRouteInfo {
+  domain: string
+  parameters: Record<string, string>
+  subdomain?: string
+  rootDomain?: string
+}
+
+/**
+ * Domain pattern parser and matcher
+ */
+export class DomainMatcher {
+  /**
+   * Parse domain pattern into regex and parameter names
+   */
+  static parseDomainPattern(pattern: string): DomainPattern {
+    const parameters: string[] = []
+
+    // Extract parameters from pattern (e.g., {account}, {subdomain})
+    const paramMatches = pattern.match(/\{([^}]+)\}/g) || []
+
+    for (const match of paramMatches) {
+      const paramName = match.slice(1, -1) // Remove { }
+      parameters.push(paramName)
+    }
+
+    // Convert pattern to regex
+    let regexPattern = pattern
+      .replace(/\./g, '\\.') // Escape dots
+      .replace(/\{([^}]+)\}/g, '([^.]+)') // Replace {param} with capture group
+
+    // Ensure full domain match
+    regexPattern = `^${regexPattern}$`
+
+    const regex = new RegExp(regexPattern, 'i') // Case insensitive
+
+    return {
+      pattern,
+      parameters,
+      regex,
+    }
+  }
+
+  /**
+   * Match domain against pattern and extract parameters
+   */
+  static matchDomain(domain: string, pattern: DomainPattern): Record<string, string> | null {
+    const match = domain.match(pattern.regex)
+    if (!match) {
+      return null
+    }
+
+    const parameters: Record<string, string> = {}
+
+    // Extract parameter values from regex groups
+    for (let i = 0; i < pattern.parameters.length; i++) {
+      const paramName = pattern.parameters[i]
+      const paramValue = match[i + 1] // match[0] is full match, parameters start at index 1
+      parameters[paramName] = paramValue
+    }
+
+    return parameters
+  }
+
+  /**
+   * Extract subdomain information from domain
+   */
+  static extractSubdomainInfo(domain: string): SubdomainRouteInfo {
+    const parts = domain.split('.')
+
+    if (parts.length <= 2) {
+      // No subdomain (e.g., example.com)
+      return {
+        domain,
+        parameters: {},
+        rootDomain: domain,
+      }
+    }
+
+    // Has subdomain (e.g., api.example.com, user.api.example.com)
+    const subdomain = parts[0]
+    const rootDomain = parts.slice(1).join('.')
+
+    return {
+      domain,
+      parameters: { subdomain },
+      subdomain,
+      rootDomain,
+    }
+  }
+}
+
+/**
+ * Domain group for organizing routes by domain patterns
+ */
+export class DomainGroup {
+  private routes: Array<{
+    method: string
+    path: string
+    handler: RouteHandler
+    middleware: MiddlewareHandler[]
+    name?: string
+  }> = []
+
+  constructor(
+    public pattern: DomainPattern,
+    public config: DomainGroupConfig,
+  ) {}
+
+  /**
+   * Add route to domain group
+   */
+  addRoute(
+    method: string,
+    path: string,
+    handler: RouteHandler,
+    middleware: MiddlewareHandler[] = [],
+    name?: string,
+  ): void {
+    // Combine group middleware with route middleware
+    const allMiddleware = [
+      ...(this.config.middleware || []),
+      ...middleware,
+    ]
+
+    // Add prefix if configured
+    const fullPath = this.config.prefix ? `${this.config.prefix}${path}` : path
+
+    this.routes.push({
+      method: method.toUpperCase(),
+      path: fullPath,
+      handler,
+      middleware: allMiddleware,
+      name: name || (this.config.name ? `${this.config.name}.${method.toLowerCase()}${path}` : undefined),
+    })
+  }
+
+  /**
+   * Get all routes in this domain group
+   */
+  getRoutes(): Array<{ method: string, path: string, handler: RouteHandler, middleware: MiddlewareHandler[] }> {
+    return [...this.routes] as Array<{ method: string, path: string, handler: RouteHandler, middleware: MiddlewareHandler[] }>
+  }
+
+  /**
+   * Check if domain matches this group's pattern
+   */
+  matchesDomain(domain: string): Record<string, string> | null {
+    return DomainMatcher.matchDomain(domain, this.pattern)
+  }
+}
+
+/**
+ * Subdomain router for managing domain-based routing
+ */
+export class SubdomainRouter {
+  private domainGroups: DomainGroup[] = []
+  private wildcardGroup?: DomainGroup // Fallback for unmatched domains
+
+  /**
+   * Create domain group with pattern
+   */
+  domain(pattern: string): DomainGroupBuilder {
+    const domainPattern = DomainMatcher.parseDomainPattern(pattern)
+    return new DomainGroupBuilder(this, domainPattern)
+  }
+
+  /**
+   * Add domain group to router
+   */
+  addDomainGroup(group: DomainGroup): void {
+    // Check if this is a wildcard pattern (no parameters, contains *)
+    if (group.pattern.pattern.includes('*') && group.pattern.parameters.length === 0) {
+      this.wildcardGroup = group
+    }
+    else {
+      this.domainGroups.push(group)
+    }
+  }
+
+  /**
+   * Find matching domain group and extract parameters
+   */
+  findDomainGroup(domain: string): { group: DomainGroup, parameters: Record<string, string> } | null {
+    // Try specific domain patterns first
+    for (const group of this.domainGroups) {
+      const parameters = group.matchesDomain(domain)
+      if (parameters !== null) {
+        return { group, parameters }
+      }
+    }
+
+    // Fall back to wildcard group if available
+    if (this.wildcardGroup) {
+      return {
+        group: this.wildcardGroup,
+        parameters: DomainMatcher.extractSubdomainInfo(domain).parameters,
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Get all routes from all domain groups
+   */
+  getAllRoutes(): Array<{
+    domainPattern: string
+    domainParameters: Record<string, string>
+    method: string
+    path: string
+    handler: RouteHandler
+    middleware: MiddlewareHandler[]
+    name?: string
+  }> {
+    const allRoutes: Array<{
+      domainPattern: string
+      domainParameters: Record<string, string>
+      method: string
+      path: string
+      handler: RouteHandler
+      middleware: MiddlewareHandler[]
+      name?: string
+    }> = []
+
+    for (const group of this.domainGroups) {
+      const routes = group.getRoutes()
+      for (const route of routes) {
+        allRoutes.push({
+          domainPattern: group.pattern.pattern,
+          domainParameters: {},
+          ...route,
+        })
+      }
+    }
+
+    if (this.wildcardGroup) {
+      const routes = this.wildcardGroup.getRoutes()
+      for (const route of routes) {
+        allRoutes.push({
+          domainPattern: this.wildcardGroup.pattern.pattern,
+          domainParameters: {},
+          ...route,
+        })
+      }
+    }
+
+    return allRoutes
+  }
+}
+
+/**
+ * Domain group builder for fluent API
+ */
+export class DomainGroupBuilder {
+  private group: DomainGroup
+
+  constructor(
+    private router: SubdomainRouter,
+    private pattern: DomainPattern,
+  ) {
+    this.group = new DomainGroup(pattern, { domain: pattern.pattern })
+  }
+
+  /**
+   * Set middleware for domain group
+   */
+  middleware(middleware: MiddlewareHandler[]): this {
+    this.group.config.middleware = middleware
+    return this
+  }
+
+  /**
+   * Set prefix for all routes in group
+   */
+  prefix(prefix: string): this {
+    this.group.config.prefix = prefix
+    return this
+  }
+
+  /**
+   * Set name prefix for routes in group
+   */
+  name(name: string): this {
+    this.group.config.name = name
+    return this
+  }
+
+  /**
+   * Define routes within domain group
+   */
+  routes(callback: (builder: RouteGroupBuilder) => void): void {
+    const routeBuilder = new RouteGroupBuilder(this.group)
+    callback(routeBuilder)
+    this.router.addDomainGroup(this.group)
+  }
+
+  /**
+   * Add single route (shorthand)
+   */
+  get(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[]): void {
+    this.group.addRoute('GET', path, handler, middleware)
+    this.router.addDomainGroup(this.group)
+  }
+
+  post(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[]): void {
+    this.group.addRoute('POST', path, handler, middleware)
+    this.router.addDomainGroup(this.group)
+  }
+
+  put(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[]): void {
+    this.group.addRoute('PUT', path, handler, middleware)
+    this.router.addDomainGroup(this.group)
+  }
+
+  delete(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[]): void {
+    this.group.addRoute('DELETE', path, handler, middleware)
+    this.router.addDomainGroup(this.group)
+  }
+
+  patch(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[]): void {
+    this.group.addRoute('PATCH', path, handler, middleware)
+    this.router.addDomainGroup(this.group)
+  }
+}
+
+/**
+ * Route group builder for defining routes within domain groups
+ */
+export class RouteGroupBuilder {
+  constructor(private group: DomainGroup) {}
+
+  get(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    this.group.addRoute('GET', path, handler, middleware, name)
+  }
+
+  post(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    this.group.addRoute('POST', path, handler, middleware, name)
+  }
+
+  put(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    this.group.addRoute('PUT', path, handler, middleware, name)
+  }
+
+  delete(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    this.group.addRoute('DELETE', path, handler, middleware, name)
+  }
+
+  patch(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    this.group.addRoute('PATCH', path, handler, middleware, name)
+  }
+
+  options(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    this.group.addRoute('OPTIONS', path, handler, middleware, name)
+  }
+
+  head(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    this.group.addRoute('HEAD', path, handler, middleware, name)
+  }
+
+  any(path: string, handler: RouteHandler, middleware?: MiddlewareHandler[], name?: string): void {
+    const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD']
+    for (const method of methods) {
+      this.group.addRoute(method, path, handler, middleware, name)
+    }
+  }
+}
+
+/**
+ * Create subdomain routing middleware
+ */
+export function createSubdomainMiddleware(subdomainRouter: SubdomainRouter) {
+  return async (req: EnhancedRequest, next: () => Promise<Response>): Promise<Response> => {
+    const url = new URL(req.url)
+    const domain = url.hostname
+
+    // Find matching domain group
+    const match = subdomainRouter.findDomainGroup(domain)
+    if (match) {
+      // Add domain parameters to request
+      const enhancedReq = req as EnhancedRequest & { domainParams?: Record<string, string> }
+      enhancedReq.domainParams = match.parameters
+
+      // Also add to regular params for convenience
+      Object.assign(req.params || {}, match.parameters)
+
+      // Add subdomain info
+      const subdomainInfo = DomainMatcher.extractSubdomainInfo(domain)
+      ;(enhancedReq as any).subdomainInfo = subdomainInfo
+    }
+
+    return await next()
+  }
+}
+
+/**
+ * Utility functions for subdomain routing
+ */
+export const SubdomainUtils = {
+  /**
+   * Extract subdomain from request
+   */
+  getSubdomain: (req: EnhancedRequest): string | null => {
+    const url = new URL(req.url)
+    const info = DomainMatcher.extractSubdomainInfo(url.hostname)
+    return info.subdomain || null
+  },
+
+  /**
+   * Get domain parameters from request
+   */
+  getDomainParams: (req: EnhancedRequest): Record<string, string> => {
+    return (req as any).domainParams || {}
+  },
+
+  /**
+   * Check if request matches domain pattern
+   */
+  matchesDomain: (req: EnhancedRequest, pattern: string): boolean => {
+    const url = new URL(req.url)
+    const domainPattern = DomainMatcher.parseDomainPattern(pattern)
+    return DomainMatcher.matchDomain(url.hostname, domainPattern) !== null
+  },
+
+  /**
+   * Get full subdomain info from request
+   */
+  getSubdomainInfo: (req: EnhancedRequest): SubdomainRouteInfo | null => {
+    return (req as any).subdomainInfo || null
+  },
+}
+
+/**
+ * Factory functions for common subdomain patterns
+ */
+export const SubdomainPatterns = {
+  /**
+   * Single subdomain pattern (e.g., api.example.com)
+   */
+  single: (subdomain: string, domain: string): string => `${subdomain}.${domain}`,
+
+  /**
+   * Wildcard subdomain pattern (e.g., {account}.example.com)
+   */
+  wildcard: (domain: string, paramName: string = 'subdomain'): string => `{${paramName}}.${domain}`,
+
+  /**
+   * Multi-level subdomain (e.g., {service}.{env}.example.com)
+   */
+  multiLevel: (domain: string, ...paramNames: string[]): string => {
+    const params = paramNames.map(name => `{${name}}`).join('.')
+    return `${params}.${domain}`
+  },
+
+  /**
+   * API versioning pattern (e.g., v1.api.example.com)
+   */
+  apiVersion: (domain: string): string => `{version}.api.${domain}`,
+
+  /**
+   * Tenant pattern (e.g., {tenant}.app.example.com)
+   */
+  tenant: (domain: string): string => `{tenant}.app.${domain}`,
+
+  /**
+   * Environment pattern (e.g., {env}.example.com)
+   */
+  environment: (domain: string): string => `{env}.${domain}`,
+}

package/src/session/database-store.ts

@@ -0,0 +1,109 @@
+import type { SessionData, SessionStore } from '../types/core'
+
+/**
+ * Minimal database adapter interface for session storage.
+ * Implement this with your ORM (Kysely, Drizzle, etc.).
+ */
+export interface SessionDatabaseAdapter {
+  findSession(sid: string): Promise<{ payload: string, last_activity: number } | null>
+  upsertSession(sid: string, payload: string, lastActivity: number): Promise<void>
+  deleteSession(sid: string): Promise<void>
+  getAllSessions(): Promise<Array<{ id: string, payload: string, last_activity: number }>>
+  deleteExpiredSessions(maxAge: number): Promise<void>
+  countSessions(): Promise<number>
+  clearAllSessions(): Promise<void>
+}
+
+/**
+ * Database-backed session store.
+ * Persists sessions in a database table.
+ *
+ * Expected table schema:
+ * ```sql
+ * CREATE TABLE sessions (
+ *   id VARCHAR(255) PRIMARY KEY,
+ *   user_id INTEGER NULL,
+ *   ip_address VARCHAR(45) NULL,
+ *   user_agent TEXT NULL,
+ *   payload TEXT NOT NULL,
+ *   last_activity INTEGER NOT NULL
+ * );
+ * ```
+ */
+export class DatabaseSessionStore implements SessionStore<SessionData> {
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null
+
+  constructor(
+    private adapter: SessionDatabaseAdapter,
+    private defaultTtl: number = 86400,
+  ) {
+    // Cleanup expired sessions every 30 minutes
+    this.cleanupInterval = setInterval(() => {
+      const maxAge = Date.now() - this.defaultTtl * 1000
+      this.adapter.deleteExpiredSessions(maxAge)
+    }, 30 * 60 * 1000)
+  }
+
+  async get(sid: string): Promise<SessionData | null> {
+    const record = await this.adapter.findSession(sid)
+    if (!record) return null
+
+    // Check expiration
+    const maxAge = Date.now() - this.defaultTtl * 1000
+    if (record.last_activity < maxAge) {
+      await this.adapter.deleteSession(sid)
+      return null
+    }
+
+    try {
+      return JSON.parse(record.payload) as SessionData
+    }
+    catch {
+      return null
+    }
+  }
+
+  async set(sid: string, session: SessionData, _ttl?: number): Promise<void> {
+    await this.adapter.upsertSession(sid, JSON.stringify(session), Date.now())
+  }
+
+  async destroy(sid: string): Promise<void> {
+    await this.adapter.deleteSession(sid)
+  }
+
+  async touch(sid: string, session: SessionData, _ttl?: number): Promise<void> {
+    await this.adapter.upsertSession(sid, JSON.stringify(session), Date.now())
+  }
+
+  async all(): Promise<Record<string, SessionData>> {
+    const records = await this.adapter.getAllSessions()
+    const result: Record<string, SessionData> = {}
+    const maxAge = Date.now() - this.defaultTtl * 1000
+
+    for (const record of records) {
+      if (record.last_activity >= maxAge) {
+        try {
+          result[record.id] = JSON.parse(record.payload)
+        }
+        catch { /* skip invalid data */ }
+      }
+    }
+
+    return result
+  }
+
+  async length(): Promise<number> {
+    return this.adapter.countSessions()
+  }
+
+  async clear(): Promise<void> {
+    await this.adapter.clearAllSessions()
+  }
+
+  dispose(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval)
+      this.cleanupInterval = null
+    }
+  }
+}