@fc3/mmcadi 0.1.0

package/src/lib/server/http/router.ts

@@ -0,0 +1,125 @@
+import Logger from 'lib/logger';
+import {HttpMethod, IncomingRequest, OutgoingResponse} from 'lib/http';
+
+import Middleware from 'lib/server/http/middleware';
+import Route from 'lib/server/http/route';
+import Endpoint from 'lib/server/http/endpoint';
+
+interface MethodRoutes {
+	[HttpMethod.DELETE]: Route[];
+	[HttpMethod.GET]: Route[];
+	[HttpMethod.HEAD]: Route[];
+	[HttpMethod.OPTIONS]: Route[];
+	[HttpMethod.PATCH]: Route[];
+	[HttpMethod.PUT]: Route[];
+	[HttpMethod.POST]: Route[];
+}
+
+interface EndpointSetupCallback {
+	(endpoint: Endpoint<any, any>): Promise<void>;
+}
+
+class Router extends Middleware {
+	private logger: Logger;
+	private method_routes: MethodRoutes;
+	private endpoint_setup_callback: EndpointSetupCallback | undefined;
+
+	public constructor(logger: Logger, endpoint_setup_callback?: EndpointSetupCallback) {
+		super();
+
+		this.logger = logger;
+		this.endpoint_setup_callback = endpoint_setup_callback;
+
+		this.method_routes = {
+			[HttpMethod.DELETE]: [],
+			[HttpMethod.GET]: [],
+			[HttpMethod.HEAD]: [],
+			[HttpMethod.OPTIONS]: [],
+			[HttpMethod.PATCH]: [],
+			[HttpMethod.PUT]: [],
+			[HttpMethod.POST]: []
+		};
+	}
+
+	public addRoute(route: Route): void {
+		const method = route.getMethod();
+		const routes = this.getRoutesForMethod(method);
+
+		routes.push(route);
+	}
+
+	// Returns a boolean indicating whether the request was successfully processed
+	// (read: we can skip subsequent middleware)
+	public async handleRequest(
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<boolean> {
+		const method = request.getMethod();
+		const routes = this.getRoutesForMethod(method);
+		const logger = this.getLogger();
+
+		if (routes.length === 0) {
+			logger.warn(`No routes matched method: ${method}`);
+
+			return false;
+		}
+
+		const path = request.getPath();
+
+		const routes_subset = routes.filter((route) => {
+			return route.matchesPath(path);
+		});
+
+		if (routes_subset.length === 0) {
+			logger.warn(`No routes matched path: ${path}`);
+
+			return false;
+		}
+
+		const content_types = request.getAcceptedContentTypes();
+
+		const matching_route = routes_subset.find((route) => {
+			return route.matchesContentTypes(content_types);
+		});
+
+		if (matching_route === undefined) {
+			logger.warn(`No routes matched content types: ${content_types}`);
+
+			return false;
+		}
+
+		// TODO: Why is this necessary, given that we're explicitly checking for
+		// undefined values above?
+		const route = matching_route;
+
+		const path_parameters = route.getPathParametersForRequest(request);
+
+		request.setPathParameters(path_parameters);
+
+		const endpoint = await route.buildEndpoint(request, response);
+
+		if (this.endpoint_setup_callback !== undefined) {
+			await this.endpoint_setup_callback(endpoint);
+		}
+
+		await endpoint.serve();
+
+		return true;
+	}
+
+	private getRoutesForMethod(method: HttpMethod): Route[] {
+		const method_routes = this.getMethodRoutes();
+
+		return method_routes[method];
+	}
+
+	private getMethodRoutes(): MethodRoutes {
+		return this.method_routes;
+	}
+
+	private getLogger(): Logger {
+		return this.logger;
+	}
+}
+
+export default Router;

package/src/lib/server/http/type/session-resolver.ts

@@ -0,0 +1,8 @@
+import {IncomingRequest} from 'lib/http';
+import {Session} from 'lib/execution-context';
+
+interface SessionResolver {
+	(request: IncomingRequest): Promise<Session | undefined>;
+}
+
+export default SessionResolver;

package/src/lib/server/http/utility/create-server.ts

@@ -0,0 +1,34 @@
+import HTTP from 'http';
+import HTTPS from 'https';
+
+import {InvalidError} from 'lib/errors';
+import {NetworkProtocol} from 'lib/network';
+
+interface ServerConfig {
+	readonly key: string | Buffer | undefined;
+	readonly cert: string | Buffer | undefined;
+	readonly protocol: NetworkProtocol;
+}
+
+function createServer(config: ServerConfig): HTTP.Server | HTTPS.Server {
+	const {key, cert, protocol} = config;
+
+	if (protocol === NetworkProtocol.HTTPS) {
+		if (key === undefined || cert === undefined) {
+			throw new InvalidError('Must specify a key and cert when using HTTPS');
+		}
+
+		return HTTPS.createServer({
+			key,
+			cert
+		});
+	}
+
+	if (key !== undefined || cert !== undefined) {
+		throw new InvalidError('SSL key/cert were supplied, but protocol was HTTP');
+	}
+
+	return HTTP.createServer();
+}
+
+export default createServer;

package/src/lib/server/http/utility/path-parser.ts

@@ -0,0 +1,49 @@
+interface ParsedPath {
+	readonly regex: RegExp;
+	readonly parameter_keys: string[];
+}
+
+class PathParser {
+	private path: string;
+
+	public constructor(path: string) {
+		this.path = path;
+	}
+
+	public parse(): ParsedPath {
+		const path = this.getPathWithoutLeadingSlash();
+		const path_parts = path.split('/');
+		const parameter_keys: string[] = [];
+
+		const regex_parts = path_parts.map((path_part) => {
+			const colon_index = path_part.indexOf(':');
+
+			if (colon_index === -1) {
+				return path_part;
+			}
+
+			const prefix = path_part.slice(0, colon_index);
+			const parameter_key = path_part.slice(colon_index + 1);
+
+			parameter_keys.push(parameter_key);
+
+			return `${prefix}([^\\/?]+)`;
+		});
+
+		const querystring = '(\\?[^/?]+)?';
+
+		const regex_string = '^/' + regex_parts.join('/') + querystring + '$';
+		const regex = new RegExp(regex_string);
+
+		return {
+			regex,
+			parameter_keys
+		};
+	}
+
+	private getPathWithoutLeadingSlash(): string {
+		return this.path.slice(1);
+	}
+}
+
+export default PathParser;

package/src/lib/server/http/utility/standardize-html-indentation.ts

@@ -0,0 +1,54 @@
+function standardizeHtmlIndentation(html: string): string {
+	const original_lines = html.split('\n');
+	const standardized_lines: string[] = [];
+
+	let indentation = '';
+	let within_multiline_block = false;
+
+	original_lines.forEach((original_line) => {
+		const trimmed_line = original_line.trim();
+
+		if (trimmed_line.length === 0) {
+			return;
+		}
+
+		if (trimmed_line === '<br>' || trimmed_line === '<hr>') {
+			throw new Error('Specify void elements as self-closing');
+		}
+
+		const has_open_tag = /^<[a-z]/.test(trimmed_line);
+		const has_close_tag = /<\/[^>]+>$/.test(trimmed_line);
+		const is_self_closing = /^<[a-z].*\/>$/.test(trimmed_line);
+
+		if (!has_open_tag && has_close_tag && !is_self_closing) {
+			indentation = indentation.slice(0, -1);
+		}
+
+		if (within_multiline_block) {
+			standardized_lines.push(original_line);
+		} else {
+			const indented_line = `${indentation}${trimmed_line}`;
+
+			standardized_lines.push(indented_line);
+		}
+
+		const multiline_open_regex = /<(pre|textarea|script)/;
+		const multiline_close_regex = /<\/(pre|textarea|script)>/;
+
+		if (has_open_tag && multiline_open_regex.test(trimmed_line)) {
+			within_multiline_block = true;
+		}
+
+		if (has_close_tag && multiline_close_regex.test(trimmed_line) && within_multiline_block) {
+			within_multiline_block = false;
+		}
+
+		if (has_open_tag && !has_close_tag && !is_self_closing) {
+			indentation += '\t';
+		}
+	});
+
+	return standardized_lines.join('\n');
+}
+
+export default standardizeHtmlIndentation;

package/src/lib/server/http/websocket-wrapper.ts

@@ -0,0 +1,83 @@
+import {EventEmitter} from 'events';
+
+import WebSocket from 'ws';
+
+import {Socket, SocketOptions} from 'lib/network';
+
+class WebsocketWrapper extends EventEmitter implements Socket {
+	public connecting: boolean;
+	public pending: boolean;
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public readyState: 'open';
+
+	private websocket: WebSocket;
+
+	public constructor(websocket: WebSocket) {
+		super();
+
+		this.connecting = false;
+		this.pending = false;
+		this.readyState = 'open';
+
+		this.websocket = websocket;
+
+		this.bindHandlers();
+		this.assignHandlers();
+	}
+
+	public write(message: string): void {
+		const websocket = this.getWebsocket();
+
+		websocket.send(message);
+	}
+
+	public end(): void {
+		const websocket = this.getWebsocket();
+
+		websocket.close();
+	}
+
+	public destroy(): void {
+		const websocket = this.getWebsocket();
+
+		websocket.terminate();
+	}
+
+	public connect(_options: SocketOptions): void {
+		throw new Error('Cannot call connect() on a server-side websocket');
+	}
+
+	private bindHandlers(): void {
+		this.handleMessage = this.handleMessage.bind(this);
+		this.handleClose = this.handleClose.bind(this);
+		this.handleError = this.handleError.bind(this);
+	}
+
+	private assignHandlers(): void {
+		const websocket = this.getWebsocket();
+
+		websocket.on('message', this.handleMessage);
+		websocket.on('close', this.handleClose);
+		websocket.on('error', this.handleError);
+	}
+
+	private handleMessage(message: string): void {
+		this.emit('data', message);
+	}
+
+	private handleClose(): void {
+		// Simulate the normal events in a native Net.Socket teardown lifecycle:
+		this.emit('end');
+		this.emit('close');
+	}
+
+	private handleError(error: Error): void {
+		this.emit('error', error);
+	}
+
+	private getWebsocket(): WebSocket {
+		return this.websocket;
+	}
+}
+
+export default WebsocketWrapper;

package/src/lib/server/http.ts

@@ -0,0 +1,301 @@
+import Net from 'net';
+import HTTP from 'http';
+import Util from 'util';
+import HTTPS from 'https';
+
+import Websocket from 'ws';
+
+import {sleep, TimeInterval} from 'lib/time';
+import {NotFoundError} from 'lib/errors';
+import {IncomingRequest, OutgoingResponse} from 'lib/http';
+import {NetworkProtocol} from 'lib/network';
+import ExecutionContext from 'lib/execution-context';
+import {IncomingConnection} from 'lib/tcp';
+
+import Route from 'lib/server/http/route';
+import Router from 'lib/server/http/router';
+import BaseServer from 'lib/server/base';
+import Middleware from 'lib/server/http/middleware';
+import Endpoint from 'lib/server/http/endpoint';
+import ServerEvent from 'lib/server/enum/server-event';
+import PingEndpoint from 'lib/server/http/endpoint/ping';
+import ServerOptions from 'lib/server/type/server-options';
+import SessionResolver from 'lib/server/http/type/session-resolver';
+import WebsocketWrapper from 'lib/server/http/websocket-wrapper';
+import EndpointConstructor from 'lib/server/http/interface/endpoint-constructor';
+
+class HttpServer extends BaseServer {
+	private router: Router;
+	private middlewares: Middleware[];
+	private connections: IncomingConnection[];
+	private session_resolver: SessionResolver | undefined;
+	private websocket_server: Websocket.Server | undefined;
+
+	public constructor(
+		options: ServerOptions,
+		raw_server?: HTTP.Server | HTTPS.Server
+	) {
+		if (raw_server === undefined) {
+			raw_server = HTTP.createServer();
+		}
+
+		super(options, raw_server);
+
+		const logger = this.getLogger();
+
+		const router = new Router(logger, (endpoint) => {
+			return this.setupEndpoint(endpoint);
+		});
+
+		this.router = router;
+		this.middlewares = [router];
+		this.connections = [];
+	}
+
+	public async stop(): Promise<void> {
+		await super.stop();
+		await this.drain();
+	}
+
+	public addEndpoint(endpoint_constructor: EndpointConstructor): this {
+		const router = this.getRouter();
+		const route = new Route(endpoint_constructor);
+
+		router.addRoute(route);
+
+		return this;
+	}
+
+	public prependMiddleware(middleware: Middleware): this {
+		const middlewares = this.getMiddlewares();
+
+		middlewares.unshift(middleware);
+
+		return this;
+	}
+
+	public appendMiddleware(middleware: Middleware): this {
+		const middlewares = this.getMiddlewares();
+
+		middlewares.push(middleware);
+
+		return this;
+	}
+
+	public enablePingEndpoint(): this {
+		this.addEndpoint(PingEndpoint);
+
+		return this;
+	}
+
+	public setSessionResolver(session_resolver: SessionResolver): void {
+		this.session_resolver = session_resolver;
+	}
+
+	protected bindHandlers(): void {
+		const raw_server = this.getRawServer();
+
+		raw_server.on('request', this.handleRawRequest.bind(this));
+		raw_server.on('upgrade', this.handleUpgrade.bind(this));
+	}
+
+	protected getProtocol(): NetworkProtocol {
+		const raw_server = this.getRawServer();
+
+		if (raw_server instanceof HTTPS.Server) {
+			return NetworkProtocol.HTTPS;
+		} else if (raw_server instanceof HTTP.Server) {
+			return NetworkProtocol.HTTP;
+		} else {
+			throw new Error('Unable to determine server protocol');
+		}
+	}
+
+	protected async setupEndpoint(endpoint: Endpoint<any, any>): Promise<void> {
+	}
+
+	private handleRawRequest(
+		raw_request: HTTP.IncomingMessage,
+		raw_response: HTTP.ServerResponse
+	): void {
+		const config = this.getConfig();
+		const execution_context = new ExecutionContext(config);
+		const request = new IncomingRequest(raw_request, execution_context);
+		const response = new OutgoingResponse(raw_response);
+
+		response.setExecutionContext(execution_context);
+		response.setPath(request.getPath());
+		response.setMethod(request.getMethod());
+
+		const promise = this.handleRequestAsync(request, response);
+
+		promise.catch((error) => {
+			response.error(error);
+		});
+	}
+
+	private async handleRequestAsync(
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<void> {
+		await this.assignSessionToRequest(request);
+
+		const middlewares = this.getMiddlewares();
+		const logger = this.getLogger();
+
+		let index = 0;
+		let error: Error | undefined = undefined;
+
+		while (index < middlewares.length) {
+			const middleware = middlewares[index];
+
+			if (error) {
+				if (await middleware.handleError(error, request, response)) {
+					return;
+				}
+			} else {
+				try {
+					if (await middleware.handleRequest(request, response)) {
+						return;
+					}
+				} catch (middleware_error) {
+					error = middleware_error as Error;
+					logger.error(error);
+				}
+			}
+
+			index++;
+		}
+
+		if (error === undefined) {
+			error = new NotFoundError(
+				'Unable to find a matching resource for this request'
+			);
+		}
+
+		response.error(error);
+	}
+
+	private handleUpgrade(
+		raw_request: HTTP.IncomingMessage,
+		socket: Net.Socket,
+		head: Buffer
+	): void {
+		const promise = this.handleUpgradeAsync(raw_request, socket, head);
+
+		promise.catch((error) => {
+			const logger = this.getLogger();
+
+			logger.error(`
+				Error occurred when upgrading websocket connection:
+				${error.message}
+			`);
+
+			socket.end();
+		});
+	}
+
+	private async handleUpgradeAsync(
+		raw_request: HTTP.IncomingMessage,
+		socket: Net.Socket,
+		head: Buffer
+	): Promise<void> {
+		const config = this.getConfig();
+		const execution_context = new ExecutionContext(config);
+		const request = new IncomingRequest(raw_request, execution_context);
+
+		await this.assignSessionToRequest(request);
+
+		const websocket_server = this.getWebsocketServer();
+
+		websocket_server.handleUpgrade(raw_request, socket, head, (websocket) => {
+			const wrapper = new WebsocketWrapper(websocket);
+			const connection = new IncomingConnection(wrapper, execution_context);
+
+			this.addConnection(connection);
+		});
+	}
+
+	private async assignSessionToRequest(
+		request: IncomingRequest
+	): Promise<void> {
+		if (!this.hasSessionResolver()) {
+			return;
+		}
+
+		const resolver = this.getSessionResolver();
+		const session = await resolver(request);
+		const execution_context = request.getExecutionContext();
+
+		if (session) {
+			execution_context.setSession(session);
+		}
+	}
+
+	private async drain(): Promise<void> {
+		const connections = this.getConnections();
+
+		connections.forEach((connection) => {
+			connection.end();
+		});
+
+		const raw_server = this.getRawServer();
+
+		const bound_method = raw_server.getConnections.bind(raw_server);
+		// eslint-disable-next-line @typescript-eslint/naming-convention
+		const getRawConnections = Util.promisify(bound_method);
+
+		let raw_connection_count = await getRawConnections();
+
+		while (raw_connection_count > 0) {
+			await sleep(TimeInterval.ONE_SECOND);
+
+			raw_connection_count = await getRawConnections();
+		}
+	}
+
+	private getRouter(): Router {
+		return this.router;
+	}
+
+	private getMiddlewares(): Middleware[] {
+		return this.middlewares;
+	}
+
+	private getWebsocketServer(): Websocket.Server {
+		if (this.websocket_server === undefined) {
+			this.websocket_server = new Websocket.Server({
+				// eslint-disable-next-line @typescript-eslint/naming-convention
+				noServer: true
+			});
+		}
+
+		return this.websocket_server;
+	}
+
+	private hasSessionResolver(): boolean {
+		return this.session_resolver !== undefined;
+	}
+
+	private getSessionResolver(): SessionResolver {
+		if (this.session_resolver === undefined) {
+			throw new Error('Tried to read session resolver, but it was not set');
+		}
+
+		return this.session_resolver;
+	}
+
+	private addConnection(connection: IncomingConnection): void {
+		const connections = this.getConnections();
+
+		connections.push(connection);
+
+		this.emit(ServerEvent.CONNECTION, connection);
+	}
+
+	private getConnections(): IncomingConnection[] {
+		return this.connections;
+	}
+}
+
+export default HttpServer;

package/src/lib/server/index.ts

@@ -0,0 +1,5 @@
+export {default as HttpServer} from 'lib/server/http';
+export {default as Middleware} from 'lib/server/http/middleware';
+export {default as Endpoint} from 'lib/server/http/endpoint';
+export {default as createServer} from 'lib/server/http/utility/create-server';
+export {default as HtmlResultSerializer} from 'lib/server/http/result-serializer/html';