You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
222 lines
7.7 KiB
222 lines
7.7 KiB
import LifecycleUnit from '../lifecycle/Unit.ts'
|
|
import {Unit} from '../lifecycle/decorators.ts'
|
|
import Routes from './Routes.ts'
|
|
import {RouterDefinition} from '../http/type/RouterDefinition.ts'
|
|
import {Collection} from '../collection/Collection.ts'
|
|
import {Route} from '../http/routing/Route.ts'
|
|
import {SimpleRoute} from '../http/routing/SimpleRoute.ts'
|
|
import {ComplexRoute} from '../http/routing/ComplexRoute.ts'
|
|
import ActivatedRoute from '../http/routing/ActivatedRoute.ts'
|
|
import {Request} from '../http/Request.ts'
|
|
import ResponseFactory from '../http/response/ResponseFactory.ts'
|
|
import {Canonical} from './Canonical.ts'
|
|
import {Logging} from '../service/logging/Logging.ts'
|
|
import {Canon} from './Canon.ts'
|
|
import {isBindable} from '../lifecycle/AppClass.ts'
|
|
import {DeepmatchRoute} from "../http/routing/DeepmatchRoute.ts";
|
|
import {RegExRoute} from "../http/routing/RegExRoute.ts";
|
|
|
|
/**
|
|
* Base type defining a single route handler.
|
|
*/
|
|
export type RouteHandler = (request: Request) => Request | Promise<Request> | ResponseFactory | Promise<ResponseFactory> | void | Promise<void>
|
|
|
|
/**
|
|
* Base type for a collection of route handlers.
|
|
*/
|
|
export type RouteHandlers = RouteHandler[]
|
|
|
|
/**
|
|
* Base type for a router definition.
|
|
*/
|
|
export interface RouteDefinition {
|
|
get?: RouteHandlers,
|
|
post?: RouteHandlers,
|
|
patch?: RouteHandlers,
|
|
delete?: RouteHandlers,
|
|
head?: RouteHandlers,
|
|
put?: RouteHandlers,
|
|
connect?: RouteHandlers,
|
|
options?: RouteHandlers,
|
|
trace?: RouteHandlers,
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given object is a valid route handler.
|
|
* @param what
|
|
* @return boolean
|
|
*/
|
|
export function isRouteHandler(what: any): what is RouteHandler {
|
|
return (
|
|
typeof what === 'function'
|
|
|| typeof what.handleRequest === 'function'
|
|
)
|
|
}
|
|
|
|
const verbs = ['get', 'post', 'patch', 'delete', 'head', 'put', 'connect', 'options', 'trace']
|
|
|
|
/**
|
|
* Lifecycle unit which processes the loaded routes and builds Route instances from them.
|
|
* @extends LifecycleUnit
|
|
*/
|
|
@Unit()
|
|
export default class Routing extends LifecycleUnit {
|
|
/**
|
|
* Mapping of route definition strings to route definitions.
|
|
* @type object
|
|
*/
|
|
protected definitions: { [key: string]: RouteDefinition } = {}
|
|
|
|
/**
|
|
* Collection of Route instances
|
|
* @type Collection<Route>
|
|
*/
|
|
protected instances: Collection<Route> = new Collection<Route>()
|
|
|
|
constructor(
|
|
protected readonly routes: Routes,
|
|
protected readonly logger: Logging,
|
|
protected readonly canon: Canon,
|
|
) {
|
|
super()
|
|
}
|
|
|
|
public async up() {
|
|
const route_groups = this.routes.all()
|
|
for ( const route_group_name of route_groups ) {
|
|
const route_group: RouterDefinition | undefined = this.routes.get(route_group_name)
|
|
if ( !route_group ) continue
|
|
|
|
const prefix = route_group.prefix || '/'
|
|
for ( const verb of verbs ) {
|
|
// @ts-ignore
|
|
if ( route_group[verb] ) {
|
|
// @ts-ignore
|
|
const group = route_group[verb]
|
|
for ( const key in group ) {
|
|
if ( !group.hasOwnProperty(key) ) continue
|
|
const handlers = Array.isArray(group[key]) ? group[key] : [group[key]]
|
|
const base = this.resolve([prefix, key])
|
|
|
|
if ( !this.definitions[base] ) {
|
|
this.definitions[base] = {}
|
|
}
|
|
|
|
// @ts-ignore
|
|
this.definitions[base][verb] = this.build_handler(handlers)
|
|
this.instances.push(this.build_route(base, key))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given a group of canonical-string handlers, build an array of route handlers.
|
|
* @param {Array<string>} group
|
|
* @return RouteHandlers
|
|
*/
|
|
public build_handler(group: string[]): RouteHandlers {
|
|
const handlers: RouteHandlers = []
|
|
for ( const item of group ) {
|
|
const ref = Canonical.resolve(item)
|
|
|
|
if ( !ref.resource ) {
|
|
this.logger.error(`Invalid canonical reference for route: ${item}. Reference must include resource (e.g. controller::)!`)
|
|
continue
|
|
}
|
|
|
|
const resource = this.canon.resource(ref.resource)
|
|
const resolved = resource.get(ref.item)
|
|
|
|
if ( !ref.particular ) {
|
|
if ( isRouteHandler(resolved) ) {
|
|
handlers.push(resolved)
|
|
} else {
|
|
throw new TypeError(`Invalid canonical reference for route: ${item}. Reference is not a valid route handler.`)
|
|
}
|
|
} else {
|
|
if ( isBindable(resolved) ) {
|
|
let handler
|
|
try {
|
|
handler = resolved.get_bound_method(ref.particular)
|
|
} catch (e) {
|
|
this.logger.error(e)
|
|
throw new Error(`Invalid canonical reference for route: ${item}. Reference particular could not be bound.`)
|
|
}
|
|
|
|
if ( isRouteHandler(handler) ) {
|
|
handlers.push(handler)
|
|
} else {
|
|
throw new TypeError(`Invalid canonical reference for route: ${item}. Reference is not a valid route handler.`)
|
|
}
|
|
} else {
|
|
throw new TypeError(`Invalid canonical reference for route: ${item}. Reference specifies particular, but resolved resource is not bindable.`)
|
|
}
|
|
}
|
|
}
|
|
return handlers
|
|
}
|
|
|
|
/**
|
|
* Given a set of route parts, resolve them to a string.
|
|
* @param {Array<string>} parts
|
|
* @return string
|
|
*/
|
|
public resolve(parts: string[]): string {
|
|
const cleaned = parts.map(part => {
|
|
if ( part.startsWith('/') ) part = part.substr(1)
|
|
if ( part.endsWith('/') ) part = part.slice(0, -1)
|
|
return part
|
|
})
|
|
|
|
let joined = cleaned.join('/')
|
|
if ( joined.startsWith('/') ) joined = joined.substr(1)
|
|
if ( joined.endsWith('/') ) joined = joined.slice(0, -1)
|
|
return `/${joined}`.toLowerCase()
|
|
}
|
|
|
|
/**
|
|
* Given a base and a key, return a new Route instance.
|
|
* @param {string} base
|
|
* @param {string} key
|
|
* @return Route
|
|
*/
|
|
public build_route(base: string, key: string): Route {
|
|
if ( key.startsWith('rex ') ) {
|
|
return new RegExRoute(base.split(key)[0], key)
|
|
} else if ( !base.includes(':') && !base.includes('*') ) {
|
|
return new SimpleRoute(base)
|
|
} else if ( base.includes('**') ) {
|
|
return new DeepmatchRoute(base)
|
|
} else {
|
|
return new ComplexRoute(base)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find the route instance given an incoming route string, if one exists.
|
|
* @param {string} incoming
|
|
* @return Route | undefined
|
|
*/
|
|
public match(incoming: string): Route | undefined {
|
|
return this.instances.firstWhere((route: Route) => route.match(incoming))
|
|
}
|
|
|
|
/**
|
|
* Given an incoming route and HTTP method, build an activated route if a matching route is found.
|
|
* @param {string} incoming
|
|
* @param {string} method
|
|
* @return ActivatedRoute | undefined
|
|
*/
|
|
public build(incoming: string, method: string): ActivatedRoute | undefined {
|
|
const route: Route | undefined = this.match(incoming)
|
|
|
|
if ( route ) {
|
|
// @ts-ignore
|
|
const handlers: RouteHandlers | undefined = this.definitions[route.route][method]
|
|
return new ActivatedRoute(incoming, route, handlers)
|
|
}
|
|
}
|
|
}
|