@basicbenframework/core 0.1.0

package/src/server/loader.js

@@ -0,0 +1,128 @@
+/**
+ * Auto-loaders for routes and middleware.
+ * Scans directories and loads files automatically.
+ */
+
+import { readdirSync, existsSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { Router } from './router.js'
+
+/**
+ * Load all route files from a directory.
+ * Each file should export a default function that receives the router.
+ *
+ * @param {string} dir - Directory to scan (default: src/routes)
+ * @returns {Router} - Router with all routes loaded
+ */
+export async function loadRoutes(dir = 'src/routes') {
+  const router = new Router()
+  const routesDir = resolve(process.cwd(), dir)
+
+  if (!existsSync(routesDir)) {
+    return router
+  }
+
+  const files = getJsFiles(routesDir)
+
+  for (const file of files) {
+    try {
+      const fileUrl = pathToFileURL(file).href
+      const module = await import(fileUrl)
+
+      if (typeof module.default === 'function') {
+        module.default(router)
+      }
+    } catch (err) {
+      console.error(`Error loading route file: ${file}`)
+      console.error(err.message)
+    }
+  }
+
+  return router
+}
+
+/**
+ * Load all middleware files from a directory.
+ * Files are loaded in alphabetical order.
+ * Each file should export a default middleware function.
+ *
+ * @param {string} dir - Directory to scan (default: src/middleware)
+ * @returns {Function[]} - Array of middleware functions
+ */
+export async function loadMiddleware(dir = 'src/middleware') {
+  const middleware = []
+  const middlewareDir = resolve(process.cwd(), dir)
+
+  if (!existsSync(middlewareDir)) {
+    return middleware
+  }
+
+  const files = getJsFiles(middlewareDir).sort()
+
+  for (const file of files) {
+    try {
+      const fileUrl = pathToFileURL(file).href
+      const module = await import(fileUrl)
+
+      if (typeof module.default === 'function') {
+        middleware.push(module.default)
+      }
+    } catch (err) {
+      console.error(`Error loading middleware file: ${file}`)
+      console.error(err.message)
+    }
+  }
+
+  return middleware
+}
+
+/**
+ * Get all .js files in a directory (recursive)
+ */
+function getJsFiles(dir, files = []) {
+  const entries = readdirSync(dir)
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry)
+    const stat = statSync(fullPath)
+
+    if (stat.isDirectory()) {
+      getJsFiles(fullPath, files)
+    } else if (entry.endsWith('.js') && !entry.endsWith('.test.js')) {
+      files.push(fullPath)
+    }
+  }
+
+  return files
+}
+
+/**
+ * Load config file if it exists
+ *
+ * @returns {Object} - Config object or empty defaults
+ */
+export async function loadConfig() {
+  const configPaths = [
+    'basicben.config.js',
+    'basicben.config.mjs'
+  ]
+
+  for (const configPath of configPaths) {
+    const fullPath = resolve(process.cwd(), configPath)
+
+    if (existsSync(fullPath)) {
+      try {
+        const fileUrl = pathToFileURL(fullPath).href
+        const module = await import(fileUrl)
+        return module.default || {}
+      } catch (err) {
+        console.error(`\x1b[31mError loading config:\x1b[0m ${configPath}`)
+        console.error(`  ${err.message}`)
+        console.error(`\x1b[2mCheck your config file syntax.\x1b[0m\n`)
+      }
+    }
+  }
+
+  return {}
+}

package/src/server/router.js

@@ -0,0 +1,281 @@
+/**
+ * Custom Router
+ *
+ * Features:
+ * - Route registration (GET, POST, PUT, PATCH, DELETE)
+ * - Route groups with shared prefix/middleware
+ * - Per-route middleware
+ * - Named routes for URL generation
+ * - Parameter parsing
+ */
+
+const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options']
+
+export class Router {
+  constructor(options = {}) {
+    this.prefix = options.prefix || ''
+    this.middleware = options.middleware || []
+    this.routes = []
+    this.namedRoutes = new Map()
+    this.groups = []
+  }
+
+  /**
+   * Register a route
+   */
+  #addRoute(method, path, ...handlers) {
+    const fullPath = this.#normalizePath(this.prefix + path)
+
+    // Last handler is the main handler, rest are middleware
+    const mainHandler = handlers.pop()
+    const routeMiddleware = handlers
+
+    // Check if first middleware arg is a string (route name)
+    let name = null
+    if (typeof routeMiddleware[0] === 'string') {
+      name = routeMiddleware.shift()
+    }
+
+    const route = {
+      method: method.toUpperCase(),
+      path: fullPath,
+      pattern: this.#pathToPattern(fullPath),
+      middleware: [...this.middleware, ...routeMiddleware],
+      handler: mainHandler,
+      name
+    }
+
+    this.routes.push(route)
+
+    if (name) {
+      this.namedRoutes.set(name, route)
+    }
+
+    return this
+  }
+
+  /**
+   * Normalize path - ensure leading slash, no trailing slash
+   */
+  #normalizePath(path) {
+    if (!path || path === '/') return '/'
+    let normalized = path.startsWith('/') ? path : '/' + path
+    return normalized.endsWith('/') ? normalized.slice(0, -1) : normalized
+  }
+
+  /**
+   * Convert path to regex pattern for matching
+   */
+  #pathToPattern(path) {
+    // Convert :param to named capture groups
+    // /users/:id -> /users/(?<id>[^/]+)
+    // Also handle catch-all: /* -> /(.*)
+    let pattern = path
+      .replace(/\/\*$/, '/(?<_catchAll>.*)')  // Catch-all at end
+      .replace(/\/:(\w+)/g, '/(?<$1>[^/]+)')
+      .replace(/\//g, '\\/')
+
+    return new RegExp(`^${pattern}$`)
+  }
+
+  /**
+   * HTTP method shortcuts
+   */
+  get(path, ...handlers) {
+    return this.#addRoute('get', path, ...handlers)
+  }
+
+  post(path, ...handlers) {
+    return this.#addRoute('post', path, ...handlers)
+  }
+
+  put(path, ...handlers) {
+    return this.#addRoute('put', path, ...handlers)
+  }
+
+  patch(path, ...handlers) {
+    return this.#addRoute('patch', path, ...handlers)
+  }
+
+  delete(path, ...handlers) {
+    return this.#addRoute('delete', path, ...handlers)
+  }
+
+  head(path, ...handlers) {
+    return this.#addRoute('head', path, ...handlers)
+  }
+
+  options(path, ...handlers) {
+    return this.#addRoute('options', path, ...handlers)
+  }
+
+  /**
+   * Register route for all methods
+   */
+  all(path, ...handlers) {
+    for (const method of METHODS) {
+      this.#addRoute(method, path, ...handlers)
+    }
+    return this
+  }
+
+  /**
+   * Create a route group with shared prefix and/or middleware
+   *
+   * Usage:
+   *   router.group('/admin', adminAuth, (group) => {
+   *     group.get('/users', listUsers)
+   *     group.get('/users/:id', showUser)
+   *   })
+   */
+  group(prefix, ...args) {
+    const callback = args.pop()
+    const groupMiddleware = args
+
+    const group = new Router({
+      prefix: this.prefix + prefix,
+      middleware: [...this.middleware, ...groupMiddleware]
+    })
+
+    callback(group)
+
+    // Merge group routes into this router
+    this.routes.push(...group.routes)
+    for (const [name, route] of group.namedRoutes) {
+      this.namedRoutes.set(name, route)
+    }
+
+    return this
+  }
+
+  /**
+   * Add middleware to all routes in this router
+   */
+  use(...middleware) {
+    this.middleware.push(...middleware)
+    return this
+  }
+
+  /**
+   * Generate URL for a named route
+   *
+   * Usage:
+   *   router.route('users.show', { id: 1 }) // => '/users/1'
+   */
+  route(name, params = {}) {
+    const route = this.namedRoutes.get(name)
+    if (!route) {
+      throw new Error(`Route '${name}' not found`)
+    }
+
+    let path = route.path
+    for (const [key, value] of Object.entries(params)) {
+      path = path.replace(`:${key}`, String(value))
+    }
+
+    return path
+  }
+
+  /**
+   * Match a request to a route
+   */
+  match(method, path) {
+    const normalizedPath = this.#normalizePath(path)
+
+    for (const route of this.routes) {
+      if (route.method !== method.toUpperCase()) continue
+
+      const match = normalizedPath.match(route.pattern)
+      if (match) {
+        return {
+          route,
+          params: match.groups || {}
+        }
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Apply routes to an app instance
+   */
+  applyTo(app) {
+    for (const route of this.routes) {
+      const method = route.method.toLowerCase()
+      const handlers = [...route.middleware, route.handler].map(wrapAsync)
+
+      app[method](route.path, ...handlers)
+    }
+
+    return app
+  }
+
+  /**
+   * Get all registered routes (for debugging/listing)
+   */
+  getRoutes() {
+    return this.routes.map(r => ({
+      method: r.method,
+      path: r.path,
+      name: r.name,
+      middlewareCount: r.middleware.length
+    }))
+  }
+}
+
+/**
+ * Resource routing helper - generates CRUD routes
+ *
+ * Usage:
+ *   router.resource('/users', UserController)
+ *
+ * Generates:
+ *   GET    /users          -> index
+ *   GET    /users/:id      -> show
+ *   POST   /users          -> create
+ *   PUT    /users/:id      -> update
+ *   DELETE /users/:id      -> destroy
+ */
+Router.prototype.resource = function(path, controller, options = {}) {
+  const name = options.name || path.replace(/^\//, '').replace(/\//g, '.')
+  const only = options.only || ['index', 'show', 'create', 'update', 'destroy']
+  const middleware = options.middleware || []
+
+  if (only.includes('index') && controller.index) {
+    this.get(path, ...middleware, `${name}.index`, controller.index)
+  }
+  if (only.includes('show') && controller.show) {
+    this.get(`${path}/:id`, ...middleware, `${name}.show`, controller.show)
+  }
+  if (only.includes('create') && controller.create) {
+    this.post(path, ...middleware, `${name}.create`, controller.create)
+  }
+  if (only.includes('update') && controller.update) {
+    this.put(`${path}/:id`, ...middleware, `${name}.update`, controller.update)
+  }
+  if (only.includes('destroy') && controller.destroy) {
+    this.delete(`${path}/:id`, ...middleware, `${name}.destroy`, controller.destroy)
+  }
+
+  return this
+}
+
+/**
+ * Create a new router instance
+ */
+export function createRouter(options) {
+  return new Router(options)
+}
+
+/**
+ * Wrap handler to catch async errors and pass to error handler
+ */
+function wrapAsync(fn) {
+  return (req, res, next) => {
+    const result = fn(req, res, next)
+    if (result && typeof result.catch === 'function') {
+      result.catch(next)
+    }
+  }
+}

package/src/server/static.js

@@ -0,0 +1,139 @@
+/**
+ * Static file serving middleware.
+ * Serves files from a directory with caching headers.
+ */
+
+import { createReadStream, statSync } from 'node:fs'
+import { join, extname, resolve } from 'node:path'
+
+const mimeTypes = {
+  '.html': 'text/html',
+  '.htm': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.webp': 'image/webp',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.otf': 'font/otf',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.pdf': 'application/pdf',
+  '.txt': 'text/plain',
+  '.xml': 'application/xml',
+  '.zip': 'application/zip'
+}
+
+const defaults = {
+  dir: 'public',
+  prefix: '/',
+  maxAge: 86400, // 24 hours in seconds
+  index: 'index.html',
+  dotfiles: 'ignore' // 'ignore', 'allow', 'deny'
+}
+
+export function serveStatic(options = {}) {
+  const config = { ...defaults, ...options }
+  const root = resolve(process.cwd(), config.dir)
+  const prefix = config.prefix.endsWith('/') ? config.prefix : config.prefix + '/'
+
+  return (req, res, next) => {
+    // Only handle GET and HEAD
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      return next()
+    }
+
+    // Check if path starts with prefix
+    let urlPath = req.path || req.url.split('?')[0]
+    if (!urlPath.startsWith(prefix) && urlPath !== config.prefix.replace(/\/$/, '')) {
+      return next()
+    }
+
+    // Remove prefix to get file path
+    let filePath = urlPath.slice(prefix.length - 1) || '/'
+
+    // Prevent directory traversal
+    if (filePath.includes('..')) {
+      res.statusCode = 403
+      res.end('Forbidden')
+      return
+    }
+
+    // Handle dotfiles
+    const segments = filePath.split('/')
+    const hasDotfile = segments.some(s => s.startsWith('.') && s !== '.')
+    if (hasDotfile) {
+      if (config.dotfiles === 'deny') {
+        res.statusCode = 403
+        res.end('Forbidden')
+        return
+      }
+      if (config.dotfiles === 'ignore') {
+        return next()
+      }
+    }
+
+    const fullPath = join(root, filePath)
+
+    // Check if file exists
+    let stat
+    try {
+      stat = statSync(fullPath)
+    } catch {
+      return next()
+    }
+
+    // If directory, try index file
+    if (stat.isDirectory()) {
+      const indexPath = join(fullPath, config.index)
+      try {
+        stat = statSync(indexPath)
+        if (!stat.isFile()) return next()
+      } catch {
+        return next()
+      }
+    }
+
+    if (!stat.isFile()) {
+      return next()
+    }
+
+    // Get mime type
+    const ext = extname(fullPath).toLowerCase()
+    const mime = mimeTypes[ext] || 'application/octet-stream'
+
+    // Set headers
+    res.setHeader('Content-Type', mime)
+    res.setHeader('Content-Length', stat.size)
+    res.setHeader('Cache-Control', `public, max-age=${config.maxAge}`)
+    res.setHeader('Last-Modified', stat.mtime.toUTCString())
+
+    // Handle HEAD request
+    if (req.method === 'HEAD') {
+      res.end()
+      return
+    }
+
+    // Stream file
+    const stream = createReadStream(fullPath)
+    stream.pipe(res)
+    stream.on('error', (err) => {
+      console.error('Static file error:', err)
+      if (!res.headersSent) {
+        res.statusCode = 500
+        res.end('Internal Server Error')
+      }
+    })
+  }
+}