@fc3/mmcadi 0.1.0

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

@@ -0,0 +1,345 @@
+/* eslint-disable @typescript-eslint/ban-types */
+
+import HTTP from 'http';
+
+import Logger from 'lib/logger';
+import KeyGenerator from 'lib/key-generator';
+import ExecutionContext, {Session} from 'lib/execution-context';
+
+import {
+	HttpMethod,
+	HttpHeader,
+	StatusCode,
+	ContentType,
+	IncomingRequest,
+	OutgoingResponse,
+	CookieSerializer
+} from 'lib/http';
+import {
+	InvalidError,
+	NotFoundError,
+	InvariantViolation,
+	NotImplementedError
+} from 'lib/errors';
+
+import ResultSerializer from 'lib/server/http/interface/result-serializer';
+import JsonResultSerializer from 'lib/server/http/result-serializer/json';
+import HtmlResultSerializer from 'lib/server/http/result-serializer/html';
+
+// TODO: Move this to server/http/type/allowed-outputs (or similar)
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type AllowedOutputs = string | Buffer | object;
+
+abstract class Endpoint<Input, Output extends AllowedOutputs> {
+	private request: IncomingRequest | undefined;
+	private response: OutgoingResponse | undefined;
+	private content_type: ContentType | undefined;
+
+	public abstract path: string;
+	public abstract method: HttpMethod;
+	public abstract content_types: ContentType[];
+
+	public setRequest(request: IncomingRequest): void {
+		this.request = request;
+	}
+
+	public setResponse(response: OutgoingResponse): void {
+		this.response = response;
+	}
+
+	public async serve(): Promise<void> {
+		const result = await this.serveInternal()
+
+		if (result === undefined) {
+			return;
+		}
+
+		this.applyNecessaryHeaders();
+
+		const response = this.getResponse();
+
+		if (typeof result === 'string' || result instanceof Buffer) {
+			response.send(result);
+			return;
+		}
+
+		const serialized_result = await this.serializeResult(result as object);
+
+		response.send(serialized_result);
+	}
+
+	protected getRequest(): IncomingRequest {
+		if (this.request === undefined) {
+			throw new InvariantViolation('Tried to read request, but it was not set');
+		}
+
+		return this.request;
+	}
+
+	protected getNativeRequest(): HTTP.IncomingMessage {
+		const request = this.getRequest();
+
+		return request.getNativeRequest();
+	}
+
+	protected getResponse(): OutgoingResponse {
+		if (this.response === undefined) {
+			throw new InvariantViolation(`
+				Tried to read response, but it was not setttt
+			`);
+		}
+
+		return this.response;
+	}
+
+	protected getNativeResponse(): HTTP.ServerResponse {
+		const response = this.getResponse();
+
+		return response.getNativeResponse();
+	}
+
+	protected getPathParameter(parameter: string): string {
+		const request = this.getRequest();
+		const value = request.getPathParameter(parameter);
+
+		if (value === undefined) {
+			throw new InvalidError(`
+				No value found for url parameter "${parameter}"
+			`);
+		}
+
+		return value;
+	}
+
+	protected getQueryParameter(
+		parameter: string
+	): string | string[] | undefined {
+		const request = this.getRequest();
+
+		return request.getQueryParameter(parameter);
+	}
+
+	protected getNumericParameter(parameter: string, fallback?: number): number {
+		const raw_value = this.getQueryParameter(parameter);
+
+		if (raw_value === undefined) {
+			if (fallback === undefined) {
+				throw new InvalidError(`Query parameter not found: ${parameter}`);
+			}
+
+			return fallback;
+		}
+
+		if (typeof raw_value !== 'string') {
+			throw new InvalidError(`
+				Invalid numeric value for parameter ${parameter}: ${raw_value}
+			`);
+		}
+
+		const parsed_value = parseFloat(raw_value);
+
+		if (isNaN(parsed_value)) {
+			throw new InvalidError(`
+				Invalid numeric value for parameter ${parameter}: ${raw_value}
+			`);
+		}
+
+		return parsed_value;
+	}
+
+	protected setStatusCode(status_code: StatusCode): void {
+		const response = this.getResponse();
+
+		response.setStatusCode(status_code);
+	}
+
+	protected getRequestBody(): Input {
+		const request = this.getRequest();
+		const data = request.getData();
+
+		return data as Input;
+	}
+
+	protected getLogger(): Logger {
+		const execution_context = this.getExecutionContext();
+
+		return execution_context.getLogger();
+	}
+
+	protected getExecutionContext(): ExecutionContext {
+		const request = this.getRequest();
+
+		return request.getExecutionContext();
+	}
+
+	protected applyCorsHeaders(
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): void {
+		const origin = request.getAllowedCorsOrigin();
+
+		response.setHeaderValue(HttpHeader.ACCESS_CONTROL_ALLOW_ORIGIN, origin);
+
+		const allowed_headers = request.getAllowedCorsHeaders();
+		const header_string = allowed_headers.join(',');
+
+		response.setHeaderValue(
+			HttpHeader.ACCESS_CONTROL_ALLOW_HEADERS,
+			header_string
+		);
+
+		response.setHeaderValue(
+			HttpHeader.ACCESS_CONTROL_ALLOW_CREDENTIALS,
+			'true'
+		);
+	}
+
+	protected getSessionId(): string {
+		const {id} = this.getSession();
+
+		return id;
+	}
+
+	protected setSession(session: Session): Session {
+		const response = this.getResponse();
+		const serializer = new CookieSerializer(session.id);
+		const cookie_value = serializer.serialize();
+		const execution_context = this.getExecutionContext();
+
+		execution_context.setSession(session);
+		response.setHeaderValue(HttpHeader.SET_COOKIE, cookie_value);
+
+		return session;
+	}
+
+	protected getSession(): Session {
+		const request = this.getRequest();
+		const execution_context = this.getExecutionContext();
+		const session = execution_context.getSession();
+		const session_id = request.getSessionIdFromCookie();
+
+		if (session_id === undefined || session === undefined || session_id !== session.id) {
+
+			return this.setSession({
+				id: KeyGenerator.generateToken(),
+				account_id: null,
+				username: null
+			});
+		}
+
+		return session;
+	}
+
+	protected getJsonResultSerializer(
+		result: object
+	): JsonResultSerializer<object> {
+		return new JsonResultSerializer(result);
+	}
+
+	protected getHtmlResultSerializer(
+		_result: object
+	): HtmlResultSerializer<object> | Promise<HtmlResultSerializer<object>> {
+		throw new NotImplementedError(
+			'Must implement getHtmlResultSerializer in child class'
+		);
+	}
+
+	protected async authorize(): Promise<void> {
+		// Noop by default, override this in child classes.
+	}
+
+	private async serveInternal(): Promise<Output | void> {
+		await this.authorize();
+		await this.parseBody();
+
+		return this.process();
+	}
+
+	private async serializeResult(result: object): Promise<string | Buffer> {
+		const serializer = await this.getResultSerializer(result);
+
+		return serializer.serialize();
+	}
+
+	private getResultSerializer(
+		result: object
+	): ResultSerializer | Promise<ResultSerializer> {
+		const content_type = this.getContentType();
+
+		switch (content_type) {
+			case ContentType.JSON:
+				return this.getJsonResultSerializer(result);
+
+			case ContentType.HTML:
+				return this.getHtmlResultSerializer(result);
+
+			default:
+				throw new Error(
+					`Unable to serialize result for content type: ${content_type}`
+				);
+		}
+	}
+
+	private parseBody(): Promise<void> {
+		const request = this.getRequest();
+
+		return request.parseBody();
+	}
+
+	private applyNecessaryHeaders(): void {
+		this.applyContentTypeHeader();
+	}
+
+	private applyContentTypeHeader(): void {
+		const content_type = this.getContentType();
+		const response = this.getResponse();
+
+		response.setHeaderValue(HttpHeader.CONTENT_TYPE, content_type);
+	}
+
+	private getContentType(): ContentType {
+		if (this.content_type === undefined) {
+			this.content_type = this.determineContentType();
+		}
+
+		return this.content_type;
+	}
+
+	private determineContentType(): ContentType {
+		const supported_content_types = this.getContentTypes();
+
+		if (supported_content_types.length === 1) {
+			return supported_content_types[0];
+		}
+
+		const request = this.getRequest();
+		const accepted_content_types = request.getAcceptedContentTypes();
+		const has_any_type = accepted_content_types.includes(ContentType.ANY);
+
+		const matching_type = accepted_content_types.find((content_type) => {
+			return supported_content_types.includes(content_type);
+		});
+
+		if (matching_type !== undefined) {
+			return matching_type;
+		}
+
+		if (has_any_type && supported_content_types.includes(ContentType.JSON)) {
+			return ContentType.JSON;
+		}
+
+		throw new NotFoundError(`
+			No matching content types found for this request
+			supported content types: ${supported_content_types}
+			accepted content types: ${accepted_content_types}
+		`);
+	}
+
+	private getContentTypes(): ContentType[] {
+		return this.content_types;
+	}
+
+	protected abstract process(): Promise<Output | void>;
+}
+
+export default Endpoint;

package/src/lib/server/http/interface/endpoint-constructor.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/ban-types */
+
+import Endpoint from 'lib/server/http/endpoint';
+
+interface EndpointConstructor {
+	new (): Endpoint<
+		object | unknown,
+		string | object | Buffer
+	>;
+}
+
+export default EndpointConstructor;

package/src/lib/server/http/interface/result-serializer.ts

@@ -0,0 +1,5 @@
+interface ResultSerializer {
+	serialize(): string;
+}
+
+export default ResultSerializer;

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

@@ -0,0 +1,18 @@
+import {IncomingRequest, OutgoingResponse} from 'lib/http';
+
+abstract class Middleware {
+	public abstract handleRequest(
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<boolean>;
+
+	public async handleError(
+		error: Error,
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<boolean> {
+		return false;
+	}
+}
+
+export default Middleware;

package/src/lib/server/http/result-serializer/html.ts

@@ -0,0 +1,92 @@
+import ResultSerializer from 'lib/server/http/interface/result-serializer';
+import standardizeHtmlIndentation from 'lib/server/http/utility/standardize-html-indentation';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+abstract class HtmlResultSerializer<ResultType extends object>
+	implements ResultSerializer {
+	private result: ResultType;
+
+	public constructor(result: ResultType) {
+		this.result = result;
+	}
+
+	public serialize(): string {
+		const title = this.getTitle();
+		const content = this.serializeContent();
+		const link_tags = this.serializeLinkTags();
+		const meta_tags = this.serializeMetaTags();
+		const body_class = this.getBodyClass();
+		const css = this.serializeCss();
+
+		const html = `
+			<!doctype html>
+			<html>
+				<head>
+					<meta charset="UTF-8">
+					<meta content="text/html;charset=utf-8" http-equiv="Content-Type" />
+					<meta content="utf-8" http-equiv="encoding" />
+					<meta name="viewport" content="width=640, user-scalable=no">
+					<meta name="robots" content="noindex" />
+					<link rel="icon" href="/public/favicon.ico" type="image/x-icon">
+					<title>${title}</title>
+					${meta_tags}
+					${link_tags}
+					${css}
+				</head>
+				<body class="${body_class}">
+					${content}
+				</body>
+			</html>
+		`;
+
+		return standardizeHtmlIndentation(html);
+	}
+
+	protected getResult(): ResultType {
+		return this.result;
+	}
+
+	// Override this as necessary on child classes:
+	protected getCssUrls(): string[] {
+		return [];
+	}
+
+	protected serializeCss(): string {
+		return '';
+	}
+
+	protected getBodyClass(): string {
+		return '';
+	}
+
+	private serializeLinkTags(): string {
+		const css_urls = this.getCssUrls();
+
+		const serialized_links = css_urls.map((url) => {
+			return `<link rel="stylesheet" href="${url}">`;
+		});
+
+		return serialized_links.join('\n');
+	}
+
+	protected serializeMetaTags(): string {
+		const meta_mappings = this.getMetaMappings();
+
+		const serialized_tags = Object.entries(meta_mappings).map((tuple) => {
+			const [key, value] = tuple;
+
+			return `<meta name="${key}" content="${value}" />`;
+		});
+
+		return serialized_tags.join('\n');
+	}
+
+	protected getMetaMappings(): Record<string, string | number | boolean> {
+		return {};
+	}
+
+	public abstract serializeContent(): string;
+	protected abstract getTitle(): string;
+}
+
+export default HtmlResultSerializer;

package/src/lib/server/http/result-serializer/json.ts

@@ -0,0 +1,23 @@
+import ResultSerializer from 'lib/server/http/interface/result-serializer';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+class JsonResultSerializer<ResultType extends object>
+	implements ResultSerializer {
+	private result: ResultType;
+
+	public constructor(result: ResultType) {
+		this.result = result;
+	}
+
+	public serialize(): string {
+		const result = this.getResult();
+
+		return JSON.stringify(result);
+	}
+
+	protected getResult(): ResultType {
+		return this.result;
+	}
+}
+
+export default JsonResultSerializer;

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

@@ -0,0 +1,104 @@
+import {HttpMethod, ContentType, PathParameters, IncomingRequest, OutgoingResponse} from 'lib/http';
+
+import EndpointConstructor from 'lib/server/http/interface/endpoint-constructor';
+import PathParser from 'lib/server/http/utility/path-parser';
+import Endpoint from 'lib/server/http/endpoint';
+
+class Route {
+	private endpoint_constructor: EndpointConstructor;
+	private method: HttpMethod;
+	private content_types: ContentType[];
+
+	private regex: RegExp;
+	private parameter_keys: string[];
+
+	public constructor(endpoint_constructor: EndpointConstructor) {
+		this.endpoint_constructor = endpoint_constructor;
+
+		const throwaway_endpoint = new endpoint_constructor();
+
+		this.method = throwaway_endpoint.method;
+		this.content_types = throwaway_endpoint.content_types;
+
+		const path = throwaway_endpoint.path;
+		const parser = new PathParser(path);
+		const parsed_path = parser.parse();
+
+		this.regex = parsed_path.regex;
+		this.parameter_keys = parsed_path.parameter_keys;
+	}
+
+	public getMethod(): HttpMethod {
+		return this.method;
+	}
+
+	public matchesPath(path: string): boolean {
+		return this.regex.test(path);
+	}
+
+	public matchesContentTypes(content_types: ContentType[]): boolean {
+		if (content_types.length === 0) {
+			// If the user agent didn't specify any accepted content types,
+			// they are going to have to live with whatever they get back.
+			return true;
+		}
+
+		const route_content_types = this.getContentTypes();
+
+		return content_types.some((content_type) => {
+			return route_content_types.includes(content_type);
+		});
+	}
+
+	public async buildEndpoint(
+		request: IncomingRequest,
+		response: OutgoingResponse
+	): Promise<Endpoint<any, any>> {
+		const endpoint_constructor = this.getEndpointConstructor();
+		const endpoint = new endpoint_constructor();
+
+		endpoint.setRequest(request);
+		endpoint.setResponse(response);
+
+		return endpoint;
+	}
+
+	public getPathParametersForRequest(request: IncomingRequest): PathParameters {
+		const path = request.getPath();
+		const regex = this.getRegex();
+		const match = path.match(regex);
+		const result: PathParameters = {};
+
+		if (match === null) {
+			return result;
+		}
+
+		const parameter_keys = this.getParameterKeys();
+
+		parameter_keys.forEach((parameter_key, index) => {
+			const parameter_value = match[index + 1];
+
+			result[parameter_key] = parameter_value;
+		});
+
+		return result;
+	}
+
+	private getEndpointConstructor(): EndpointConstructor {
+		return this.endpoint_constructor;
+	}
+
+	private getParameterKeys(): string[] {
+		return this.parameter_keys;
+	}
+
+	private getRegex(): RegExp {
+		return this.regex;
+	}
+
+	private getContentTypes(): ContentType[] {
+		return [...this.content_types, ContentType.ANY];
+	}
+}
+
+export default Route;