445 lines
13 KiB
TypeScript
445 lines
13 KiB
TypeScript
/**
|
|
* Route Object
|
|
*
|
|
* @typedef Route
|
|
* @property {string} method HTTP request method
|
|
* @property {string} url URL String
|
|
* @property {RouterHandler[]} handlers Array of handler functions
|
|
*/
|
|
interface Route {
|
|
method: string
|
|
url: string
|
|
handlers: RouterHandler[]
|
|
}
|
|
|
|
/**
|
|
* Router Context
|
|
*
|
|
* @typedef RouterContext
|
|
* @property {Object<string, string>} env Environment
|
|
* @property {RouterRequest} req Request Object
|
|
* @property {RouterResponse} res Response Object
|
|
* @property {RouterNext} next Next Handler
|
|
*/
|
|
interface RouterContext {
|
|
env: any
|
|
req: RouterRequest
|
|
res: RouterResponse
|
|
next: RouterNext
|
|
}
|
|
|
|
/**
|
|
* Request Object
|
|
*
|
|
* @typedef RouterRequest
|
|
* @property {string} url URL
|
|
* @property {string} method HTTP request method
|
|
* @property {RouterRequestParams} params Object containing all parameters defined in the url string
|
|
* @property {RouterRequestQuery} query Object containing all query parameters
|
|
* @property {Headers} headers Request headers object
|
|
* @property {any} body Only available if method is `POST`, `PUT`, `PATCH` or `DELETE`. Contains either the received body string or a parsed object if valid JSON was sent.
|
|
* @property {IncomingRequestCfProperties=} cf object containing custom Cloudflare properties. (https://developers.cloudflare.com/workers/examples/accessing-the-cloudflare-object)
|
|
*/
|
|
interface RouterRequest {
|
|
url: string
|
|
method: string
|
|
params: RouterRequestParams
|
|
query: RouterRequestQuery
|
|
headers: Headers
|
|
body: any
|
|
cf?: IncomingRequestCfProperties
|
|
}
|
|
|
|
interface RouterRequestParams {
|
|
[key: string]: string
|
|
}
|
|
|
|
interface RouterRequestQuery {
|
|
[key: string]: string
|
|
}
|
|
|
|
/**
|
|
* Response Object
|
|
*
|
|
* @typedef RouterResponse
|
|
* @property {Headers} headers Response headers object
|
|
* @property {number=204} status Return status code (default: `204`)
|
|
* @property {any=} body Either an `object` (will be converted to JSON) or a string
|
|
* @property {Response=} raw A response object that is to be returned, this will void all other res properties and return this as is.
|
|
*/
|
|
interface RouterResponse {
|
|
headers: Headers
|
|
status?: number
|
|
body?: any
|
|
raw?: Response,
|
|
webSocket?: WebSocket
|
|
}
|
|
|
|
/**
|
|
* Next Function
|
|
*
|
|
* @callback RouterNext
|
|
* @returns {Promise}
|
|
*/
|
|
interface RouterNext {
|
|
(): Promise<void>
|
|
}
|
|
|
|
/**
|
|
* Handler Function
|
|
*
|
|
* @callback RouterHandler
|
|
* @param {RouterContext} ctx
|
|
* @returns {Promise<void> | void}
|
|
*/
|
|
interface RouterHandler {
|
|
(ctx: RouterContext): Promise<void> | void
|
|
}
|
|
|
|
/**
|
|
* CORS Config
|
|
*
|
|
* @typedef RouterCorsConfig
|
|
* @property {string} allowOrigin Access-Control-Allow-Origin (default: `*`)
|
|
* @property {string} allowMethods Access-Control-Allow-Methods (default: `*`)
|
|
* @property {string} allowHeaders Access-Control-Allow-Headers (default: `*`)
|
|
* @property {number} maxAge Access-Control-Max-Age (default: `86400`)
|
|
* @property {number} optionsSuccessStatus Return status code for OPTIONS request (default: `204`)
|
|
*/
|
|
interface RouterCorsConfig {
|
|
allowOrigin: string
|
|
allowMethods: string
|
|
allowHeaders: string
|
|
maxAge: number
|
|
optionsSuccessStatus: number
|
|
}
|
|
|
|
|
|
/**
|
|
* Router
|
|
*
|
|
* @class
|
|
* @constructor
|
|
* @public
|
|
*/
|
|
class Router {
|
|
|
|
/**
|
|
* Router Array
|
|
*
|
|
* @protected
|
|
* @type {Route[]}
|
|
*/
|
|
protected routes: Route[] = []
|
|
|
|
/**
|
|
* Global Handlers
|
|
*/
|
|
protected globalHandlers: RouterHandler[] = []
|
|
|
|
/**
|
|
* Debug Mode
|
|
*
|
|
* @protected
|
|
* @type {boolean}
|
|
*/
|
|
protected debugMode: boolean = false
|
|
|
|
/**
|
|
* CORS Config
|
|
*
|
|
* @protected
|
|
* @type {RouterCorsConfig}
|
|
*/
|
|
protected corsConfig: RouterCorsConfig = {
|
|
allowOrigin: '*',
|
|
allowMethods: '*',
|
|
allowHeaders: '*',
|
|
maxAge: 86400,
|
|
optionsSuccessStatus: 204
|
|
}
|
|
|
|
/**
|
|
* Register global handlers
|
|
*
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public use(...handlers: RouterHandler[]): Router {
|
|
for (let handler of handlers) {
|
|
this.globalHandlers.push(handler)
|
|
}
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Register CONNECT route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public connect(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('CONNECT', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register DELETE route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public delete(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('DELETE', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register GET route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public get(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('GET', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register HEAD route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public head(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('HEAD', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register OPTIONS route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public options(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('OPTIONS', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register PATCH route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public patch(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('PATCH', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register POST route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public post(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('POST', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register PUT route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public put(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('PUT', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register TRACE route
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public trace(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('TRACE', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Register route, ignoring method
|
|
*
|
|
* @param {string} url
|
|
* @param {RouterHandler[]} handlers
|
|
* @returns {Router}
|
|
*/
|
|
public any(url: string, ...handlers: RouterHandler[]): Router {
|
|
return this.register('*', url, handlers)
|
|
}
|
|
|
|
/**
|
|
* Debug Mode
|
|
*
|
|
* @param {boolean} [state=true] Whether to turn on or off debug mode (default: true)
|
|
* @returns {Router}
|
|
*/
|
|
public debug(state = true): Router {
|
|
this.debugMode = state
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Enable CORS support
|
|
*
|
|
* @param {RouterCorsConfig} config
|
|
* @returns {Router}
|
|
*/
|
|
public cors(config: RouterCorsConfig): Router {
|
|
config = config || {}
|
|
this.corsConfig = {
|
|
allowOrigin: config.allowOrigin || '*',
|
|
allowMethods: config.allowMethods || '*',
|
|
allowHeaders: config.allowHeaders || '*, Authorization',
|
|
maxAge: config.maxAge || 86400,
|
|
optionsSuccessStatus: config.optionsSuccessStatus || 204
|
|
}
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Register route
|
|
*
|
|
* @private
|
|
* @param {string} method HTTP request method
|
|
* @param {string} url URL String
|
|
* @param {RouterHandler[]} handlers Arrar of handler functions
|
|
* @returns {Router}
|
|
*/
|
|
private register(method: string, url: string, handlers: RouterHandler[]): Router {
|
|
this.routes.push({
|
|
method,
|
|
url,
|
|
handlers
|
|
})
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Get Route by request
|
|
*
|
|
* @private
|
|
* @param {Request} request
|
|
* @returns {RouterRequest | undefined}
|
|
*/
|
|
private getRoute(request: RouterRequest): Route | undefined {
|
|
const url = new URL(request.url)
|
|
const pathArr = url.pathname.split('/').filter(i => i)
|
|
return this.routes.find(r => {
|
|
const routeArr = r.url.split('/').filter(i => i)
|
|
if (![request.method, '*'].includes(r.method) || routeArr.length !== pathArr.length)
|
|
return false
|
|
const params: RouterRequestParams = {}
|
|
for (let i = 0; i < routeArr.length; i++) {
|
|
if (routeArr[i] !== pathArr[i] && routeArr[i][0] !== ':')
|
|
return false
|
|
if (routeArr[i][0] === ':')
|
|
params[routeArr[i].substring(1)] = pathArr[i]
|
|
}
|
|
request.params = params
|
|
const query: any = {}
|
|
for (const [k, v] of url.searchParams.entries()) {
|
|
query[k] = v
|
|
}
|
|
request.query = query
|
|
return true
|
|
}) || this.routes.find(r => r.url === '*' && [request.method, '*'].includes(r.method))
|
|
}
|
|
|
|
/**
|
|
* Handle requests
|
|
*
|
|
* @param {any} env
|
|
* @param {Request} request
|
|
* @param {any=} extend
|
|
* @returns {Response}
|
|
*/
|
|
public async handle(env: any, request: Request, extend: any = {}) {
|
|
try {
|
|
const req: RouterRequest = {
|
|
...extend,
|
|
method: request.method,
|
|
headers: request.headers,
|
|
url: request.url,
|
|
cf: request.cf,
|
|
params: {},
|
|
query: {},
|
|
body: ''
|
|
}
|
|
if (req.method === 'OPTIONS' && Object.keys(this.corsConfig).length) {
|
|
return new Response(null, {
|
|
headers: {
|
|
'Access-Control-Allow-Origin': this.corsConfig.allowOrigin,
|
|
'Access-Control-Allow-Methods': this.corsConfig.allowMethods,
|
|
'Access-Control-Allow-Headers': this.corsConfig.allowHeaders,
|
|
'Access-Control-Max-Age': this.corsConfig.maxAge.toString()
|
|
},
|
|
status: this.corsConfig.optionsSuccessStatus
|
|
})
|
|
}
|
|
if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
|
|
if (req.headers.has('Content-Type') && req.headers.get('Content-Type')!.includes('json')) {
|
|
try {
|
|
req.body = await request.json()
|
|
} catch {
|
|
req.body = {}
|
|
}
|
|
} else {
|
|
try {
|
|
req.body = await request.text()
|
|
} catch {
|
|
req.body = ''
|
|
}
|
|
}
|
|
}
|
|
const route = this.getRoute(req)
|
|
if (!route)
|
|
return new Response(this.debugMode ? 'Route not found!' : null, { status: 404 })
|
|
const res: RouterResponse = { headers: new Headers() }
|
|
if (Object.keys(this.corsConfig).length) {
|
|
res.headers.set('Access-Control-Allow-Origin', this.corsConfig.allowOrigin)
|
|
res.headers.set('Access-Control-Allow-Methods', this.corsConfig.allowMethods)
|
|
res.headers.set('Access-Control-Allow-Headers', this.corsConfig.allowHeaders)
|
|
res.headers.set('Access-Control-Max-Age', this.corsConfig.maxAge.toString())
|
|
}
|
|
const handlers = [...this.globalHandlers, ...route.handlers]
|
|
let prevIndex = -1
|
|
const runner = async (index: number) => {
|
|
if (index === prevIndex)
|
|
throw new Error('next() called multiple times')
|
|
prevIndex = index
|
|
if (typeof handlers[index] === 'function')
|
|
await handlers[index]({ env, req, res, next: async () => await runner(index + 1) })
|
|
}
|
|
await runner(0)
|
|
if (typeof res.body === 'object') {
|
|
if (!res.headers.has('Content-Type'))
|
|
res.headers.set('Content-Type', 'application/json')
|
|
res.body = JSON.stringify(res.body)
|
|
}
|
|
if (res.raw)
|
|
return res.raw
|
|
return new Response([101, 204, 205, 304].includes(res.status || (res.body ? 200 : 204)) ? null : res.body, { status: res.status, headers: res.headers, webSocket: res.webSocket || null })
|
|
} catch(err) {
|
|
console.error(err)
|
|
return new Response(this.debugMode && err instanceof Error ? err.stack : '', { status: 500 })
|
|
}
|
|
}
|
|
}
|
|
|
|
export default Router
|