@stacksjs/router 0.58.48 → 0.58.50

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/router",
   "type": "module",
-  "version": "0.58.48",
+  "version": "0.58.50",
   "description": "The Stacks framework router.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -39,7 +39,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './middleware'
+export * from './request'
+export * from './server'
+export * from './router'

package/src/middleware.ts

@@ -0,0 +1,34 @@
+import { appPath } from '@stacksjs/path'
+import type { MiddlewareType } from '@stacksjs/types'
+
+export class Middleware implements MiddlewareType {
+  name: string
+  priority: number
+
+  handle: Function
+
+  constructor(data: MiddlewareType) {
+    this.name = data.name
+    this.priority = data.priority
+    this.handle = data.handle
+  }
+}
+
+// const readdir = promisify(fs.readdir)
+
+async function importMiddlewares(directory: string) {
+  // const middlewares = []
+  // TODO: somehow this breaks ./buddy dev
+  // const files = await readdir(directory)
+
+  // for (const file of files) {
+  //   // Dynamically import the middleware
+  //   const imported = await import(path.join(directory, file))
+  //   middlewares.push(imported.default)
+  // }
+
+  // return middlewares
+  return [directory] // fix this: return array of middlewares
+}
+
+export const middlewares = await importMiddlewares(appPath('middleware'))

package/src/request.ts

@@ -0,0 +1,44 @@
+interface RequestData {
+  [key: string]: string
+}
+
+type RouteParams = { [key: string]: string } | null
+
+export class Request {
+  private query: RequestData = {}
+  private params: RouteParams = null
+
+  public addQuery(url: URL): void {
+    this.query = Object.fromEntries(url.searchParams)
+  }
+
+  public get(element: string): string | number | undefined {
+    return this.query[element]
+  }
+
+  public all(): RequestData {
+    return this.query
+  }
+
+  public has(element: string): boolean {
+    return element in this.query
+  }
+
+  public isEmpty(): boolean {
+    return Object.keys(this.query).length === 0
+  }
+
+  public extractParamsFromRoute(routePattern: string, pathname: string): void {
+    const pattern = new RegExp(`^${routePattern.replace(/:(\w+)/g, (match, paramName) => `(?<${paramName}>\\w+)`)}$`)
+    const match = pattern.exec(pathname)
+
+    if (match?.groups)
+      this.params = match?.groups
+  }
+
+  public getParams(key: string): number | string | null {
+    return this.params ? (this.params[key] || null) : null
+  }
+}
+
+export const request = new Request()

package/src/router.ts

@@ -0,0 +1,162 @@
+import type { RedirectCode, Route, RouteGroupOptions, StatusCode } from '@stacksjs/types'
+import { projectPath } from '@stacksjs/path'
+
+export interface RouterInterface {
+  get(url: Route['url'], callback: Route['callback']): this
+  post(url: Route['url'], callback: Route['callback']): this
+  view(url: Route['url'], callback: Route['callback']): this
+  redirect(url: Route['url'], callback: Route['callback'], status?: RedirectCode): this
+  delete(url: Route['url'], callback: Route['callback']): this
+  patch(url: Route['url'], callback: Route['callback']): this
+  put(url: Route['url'], callback: Route['callback']): this
+  group(options: RouteGroupOptions, callback: () => void): this
+  name(name: string): this
+  middleware(middleware: Route['middleware']): this
+  getRoutes(): Promise<Route[]>
+}
+
+export class Router implements RouterInterface {
+  private routes: Route[] = []
+
+  private addRoute(method: Route['method'], uri: string, callback: Route['callback'] | string | object, statusCode: StatusCode): void {
+    const name = uri.replace(/\//g, '.').replace(/:/g, '') // we can improve this
+    const pattern = new RegExp(`^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
+      return '([a-zA-Z0-9-]+)'
+    })}$`)
+
+    let routeCallback: Route['callback']
+
+    if (typeof callback === 'string' || typeof callback === 'object') {
+      // Convert string or object to RouteCallback
+      routeCallback = () => callback
+    }
+    else {
+      routeCallback = callback
+    }
+
+    this.routes.push({
+      name,
+      method,
+      url: uri,
+      uri,
+      callback: routeCallback,
+      pattern,
+      statusCode,
+      paramNames: [],
+    })
+  }
+
+  public get(path: Route['url'], callback: Route['callback']): this {
+    this.addRoute('GET', path, callback, 200)
+    return this
+  }
+
+  public post(path: Route['url'], callback: Route['callback']): this {
+    this.addRoute('POST', path, callback, 201)
+    return this
+  }
+
+  public view(path: Route['url'], callback: Route['callback']): this {
+    this.addRoute('GET', path, callback, 200)
+    return this
+  }
+
+  public redirect(path: Route['url'], callback: Route['callback'], _status?: RedirectCode): this {
+    this.addRoute('GET', path, callback, 302)
+    return this
+  }
+
+  public delete(path: Route['url'], callback: Route['callback']): this {
+    this.addRoute('DELETE', path, callback, 204)
+    return this
+  }
+
+  public patch(path: Route['url'], callback: Route['callback']): this {
+    this.addRoute('PATCH', path, callback, 202)
+    return this
+  }
+
+  public put(path: Route['url'], callback: Route['callback']): this {
+    this.addRoute('PUT', path, callback, 202)
+    return this
+  }
+
+  public group(options: RouteGroupOptions | (() => void), callback?: () => void): this {
+    let cb: () => void
+
+    if (typeof options === 'function') {
+      cb = options
+      options = {}
+    }
+    else {
+      if (!callback)
+        throw new Error('Missing callback function for route group.')
+      cb = callback
+    }
+
+    const { prefix = '', middleware = [] } = options
+
+    // Save a reference to the original routes array.
+    const originalRoutes = this.routes
+
+    // Create a new routes array for the duration of the callback.
+    this.routes = []
+
+    // Execute the callback. This will add routes to the new this.routes array.
+    cb()
+
+    // For each route added by the callback, adjust the URI and add to the original routes array.
+    this.routes.forEach((r) => {
+      r.uri = `${prefix}${r.uri}`
+
+      if (middleware.length)
+        r.middleware = middleware
+      // Assuming you have a middleware property for each route.
+
+      originalRoutes.push(r)
+      return this
+    })
+
+    // Restore the original routes array.
+    this.routes = originalRoutes
+
+    return this
+  }
+
+  public name(name: string): this {
+    // @ts-expect-error - this is fine for now
+    this.routes[this.routes.length - 1].name = name
+
+    return this
+  }
+
+  public middleware(middleware: Route['middleware']): this {
+    // @ts-expect-error - this is fine for now
+    this.routes[this.routes.length - 1].middleware = middleware
+
+    return this
+  }
+
+  public prefix(prefix: string): this {
+    // @ts-expect-error - this is fine for now
+    this.routes[this.routes.length - 1].prefix = prefix
+
+    return this
+  }
+
+  public async getRoutes(): Promise<Route[]> {
+    // const routeFileData = (await readTextFile(projectPath('routes/web.ts'))).data
+
+    await import(projectPath('routes/api.ts'))
+
+    // run routes/web.ts
+    // const webRoutesPath = projectPath('routes/web.ts')
+    // await runCommand(`bun ${webRoutesPath}`)
+
+    // set this.routes to a mapped array of routes that matches the pattern
+
+    return this.routes
+  }
+}
+
+export const route = new Router()

package/src/server.ts

@@ -0,0 +1,154 @@
+import { extname } from 'node:path'
+import { URL } from 'node:url'
+import type { MiddlewareType, Route, StatusCode } from '@stacksjs/types'
+import { localUrl } from '@stacksjs/config'
+import { middlewares } from './middleware'
+import { request } from './request'
+import { route } from '.'
+
+interface ServeOptions {
+  host?: string
+  port?: number
+  tunnel?: boolean
+}
+
+export async function serve(options: ServeOptions = {}) {
+  const hostname = options.host || options.tunnel ? await localUrl({ type: 'backend' }) : '127.0.0.1'
+  const port = options.port || 3000
+
+  Bun.serve({
+    hostname,
+    port,
+
+    fetch(req: Request) {
+      // eslint-disable-next-line no-console
+      console.log(req)
+      return serverResponse(req)
+    },
+  })
+}
+
+export async function serverResponse(req: Request) {
+  // eslint-disable-next-line no-console
+  console.log('serverResponse', req)
+  const routesList: Route[] = await route.getRoutes()
+  const url = new URL(req.url)
+
+  const foundRoute: Route | undefined = routesList.find((route: Route) => {
+    const pattern = new RegExp(`^${route.uri.replace(/:\w+/g, '\\w+')}$`)
+
+    return pattern.test(url.pathname)
+  })
+
+  // if (url.pathname === '/favicon.ico')
+  //   return new Response('')
+
+  if (!foundRoute)
+    return new Response('Not found', { status: 404 }) // TODO: create a pretty 404 page
+
+  addRouteParamsAndQuery(url, foundRoute)
+  executeMiddleware(foundRoute)
+
+  return execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
+}
+
+function addRouteParamsAndQuery(url: URL, route: Route): void {
+  if (!isObjectNotEmpty(url.searchParams))
+    request.addQuery(url)
+
+  request.extractParamsFromRoute(route.uri, url.pathname)
+}
+
+function executeMiddleware(route: Route): void {
+  const { middleware = null } = route
+
+  if (middleware && middlewares && isObjectNotEmpty(middlewares)) {
+    if (isString(middleware)) {
+      const middlewareItem: MiddlewareType = middlewares.find((middlewareItem: MiddlewareType) => {
+        return middlewareItem.name === middleware
+      })
+
+      if (middlewareItem)
+        middlewareItem.handle() // Invoke only if it exists and is not undefined.
+    }
+    else {
+      middleware.forEach((m) => {
+        const middlewareItem: MiddlewareType = middlewares.find((middlewareItem: MiddlewareType) => {
+          return middlewareItem.name === m
+        })
+
+        if (middlewareItem)
+          middlewareItem.handle() // Again, invoke only if it exists.
+      })
+    }
+  }
+}
+
+interface Options {
+  statusCode?: StatusCode
+}
+
+function execute(route: Route, request: Request, { statusCode }: Options) {
+  if (!statusCode)
+    statusCode = 200
+
+  if (route?.method === 'GET' && (statusCode === 301 || statusCode === 302)) {
+    const callback = String(route.callback)
+    const response = Response.redirect(callback, statusCode)
+
+    return noCache(response)
+  }
+
+  if (route?.method !== request.method)
+    return new Response('Method not allowed', { status: 405 })
+
+  // Check if it's a path to an HTM L file
+  if (isString(route.callback) && extname(route.callback) === '.html') {
+    try {
+      const fileContent = Bun.file(route.callback)
+
+      return new Response(fileContent, { headers: { 'Content-Type': 'text/html' } })
+    }
+    catch (error) {
+      return new Response('Error reading the HTML file', { status: 500 })
+    }
+  }
+
+  if (isString(route.callback))
+    return new Response(route.callback)
+
+  if (isFunction(route.callback)) {
+    const result = (route.callback)()
+    return new Response(JSON.stringify(result))
+  }
+
+  if (isObject(route.callback))
+    return new Response(JSON.stringify(route.callback))
+
+  // If no known type matched, return a generic error.
+  return new Response('Unknown callback type.', { status: 500 })
+}
+
+function noCache(response: Response) {
+  response.headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate')
+  response.headers.set('Pragma', 'no-cache')
+  response.headers.set('Expires', '0')
+
+  return response
+}
+
+function isString(val: unknown): val is string {
+  return typeof val === 'string'
+}
+
+function isObjectNotEmpty(obj: object): boolean {
+  return Object.keys(obj).length > 0
+}
+
+function isFunction(val: unknown): val is Function {
+  return typeof val === 'function'
+}
+
+function isObject(val: unknown): val is object {
+  return val !== null && typeof val === 'object' && !Array.isArray(val)
+}