@fc3/mmcadi 0.1.0 → 0.1.1

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

@@ -1,125 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,301 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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';