swaf/src/Controller.ts

195 lines
6.4 KiB
TypeScript
Raw Normal View History

import express, {IRouter, RequestHandler, Router} from "express";
2020-04-22 15:52:17 +02:00
import {PathParams} from "express-serve-static-core";
import config from "config";
import {log} from "./Logger";
import FileUploadMiddleware from "./FileUploadMiddleware";
2020-07-15 11:42:49 +02:00
import * as querystring from "querystring";
import {ParsedUrlQueryInput} from "querystring";
import Middleware, {MiddlewareType} from "./Middleware";
import Application from "./Application";
2020-04-22 15:52:17 +02:00
export default abstract class Controller {
private static readonly routes: { [p: string]: string | undefined } = {};
public static route(
route: string,
params: RouteParams = [],
query: ParsedUrlQueryInput = {},
absolute: boolean = false,
): string {
2020-04-22 15:52:17 +02:00
let path = this.routes[route];
if (path === undefined) throw new Error(`Unknown route for name ${route}.`);
if (typeof params === 'string' || typeof params === 'number') {
path = path.replace(/:[a-zA-Z_-]+\??/g, '' + params);
2020-04-22 15:52:17 +02:00
} else if (Array.isArray(params)) {
let i = 0;
for (const match of path.matchAll(/:[a-zA-Z_-]+(\(.*\))?\??/g)) {
2020-04-22 15:52:17 +02:00
if (match.length > 0) {
path = path.replace(match[0], typeof params[i] !== 'undefined' ? params[i] : '');
}
i++;
}
path = path.replace(/\/+/g, '/');
2020-04-22 15:52:17 +02:00
} else {
for (const key of Object.keys(params)) {
path = path.replace(new RegExp(`:${key}\\??`), params[key]);
2020-04-22 15:52:17 +02:00
}
}
2020-07-15 11:42:49 +02:00
const queryStr = querystring.stringify(query);
return `${absolute ? config.get<string>('base_url') : ''}${path}` + (queryStr.length > 0 ? '?' + queryStr : '');
2020-04-22 15:52:17 +02:00
}
private readonly router: Router = express.Router();
private readonly fileUploadFormRouter: Router = express.Router();
private app?: Application;
2020-04-22 15:52:17 +02:00
public getGlobalMiddlewares(): Middleware[] {
2020-04-22 15:52:17 +02:00
return [];
}
public hasGlobalMiddlewares(): boolean {
return this.getGlobalMiddlewares().length > 0;
2020-04-22 15:52:17 +02:00
}
public setupGlobalHandlers(router: Router): void {
for (const middleware of this.getGlobalMiddlewares()) {
router.use(this.wrap(middleware.getRequestHandler()));
2020-04-22 15:52:17 +02:00
}
}
public getRoutesPrefix(): string {
return '/';
}
public abstract routes(): void;
public setupRoutes(): { mainRouter: Router, fileUploadFormRouter: Router } {
2020-04-22 15:52:17 +02:00
this.routes();
return {
mainRouter: this.router,
fileUploadFormRouter: this.fileUploadFormRouter,
};
2020-04-22 15:52:17 +02:00
}
protected use(handler: RequestHandler): void {
this.router.use(this.wrap(handler));
2020-04-22 15:52:17 +02:00
}
2020-12-30 14:10:58 +01:00
protected useMiddleware(...middlewares: MiddlewareType<Middleware>[]): void {
for (const middleware of middlewares) {
const instance = new middleware(this.getApp());
if (instance instanceof FileUploadMiddleware) {
this.fileUploadFormRouter.use(this.wrap(instance.getRequestHandler()));
} else {
this.router.use(this.wrap(instance.getRequestHandler()));
}
}
}
protected get(
path: PathParams,
handler: RequestHandler,
routeName?: string,
...middlewares: (MiddlewareType<Middleware>)[]
): void {
this.handle('get', path, handler, routeName, ...middlewares);
2020-04-22 15:52:17 +02:00
}
protected post(
path: PathParams,
handler: RequestHandler,
routeName?: string,
...middlewares: (MiddlewareType<Middleware>)[]
): void {
this.handle('post', path, handler, routeName, ...middlewares);
2020-04-22 15:52:17 +02:00
}
protected put(
path: PathParams,
handler: RequestHandler,
routeName?: string,
...middlewares: (MiddlewareType<Middleware>)[]
): void {
this.handle('put', path, handler, routeName, ...middlewares);
}
protected delete(
path: PathParams,
handler: RequestHandler,
routeName?: string,
...middlewares: (MiddlewareType<Middleware>)[]
): void {
this.handle('delete', path, handler, routeName, ...middlewares);
}
private handle(
action: Exclude<keyof IRouter, 'stack' | 'param' | 'route' | 'use'>,
path: PathParams,
handler: RequestHandler,
routeName?: string,
...middlewares: (MiddlewareType<Middleware>)[]
): void {
this.registerRoutes(path, handler, routeName);
for (const middleware of middlewares) {
const instance = new middleware(this.getApp());
if (instance instanceof FileUploadMiddleware) {
this.fileUploadFormRouter[action](path, this.wrap(instance.getRequestHandler()));
} else {
this.router[action](path, this.wrap(instance.getRequestHandler()));
}
}
this.router[action](path, this.wrap(handler));
}
2020-04-22 15:52:17 +02:00
private wrap(handler: RequestHandler): RequestHandler {
return async (req, res, next) => {
try {
await handler.call(this, req, res, next);
} catch (e) {
next(e);
2020-04-22 15:52:17 +02:00
}
};
}
private registerRoutes(path: PathParams, handler: RequestHandler, routeName?: string) {
if (typeof routeName !== 'string') {
routeName = handler.name
.replace(/(?:^|\.?)([A-Z])/g, (x, y) => '_' + y.toLowerCase())
.replace(/(^_|get_|post_)/g, '');
}
if (routeName.length === 0) return;
let routePath = null;
if (path instanceof Array && path.length > 0) {
path = path[0];
}
if (typeof path === 'string') {
const prefix = this.getRoutesPrefix();
routePath = (prefix !== '/' ? prefix : '') + path;
}
if (!Controller.routes[routeName]) {
if (typeof routePath === 'string') {
log.info(`Route ${routeName} has path ${routePath}`);
2020-04-22 15:52:17 +02:00
Controller.routes[routeName] = routePath;
} else {
log.warn(`Cannot assign path to route ${routeName}.`);
2020-04-22 15:52:17 +02:00
}
}
}
protected getApp(): Application {
if (!this.app) throw new Error('Application not initialized.');
return this.app;
}
public setApp(app: Application): void {
this.app = app;
}
2020-04-22 15:52:17 +02:00
}
export type RouteParams = { [p: string]: string } | string[] | string | number;