@fc3/mmcadi 0.1.0 → 0.1.2

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

@@ -1,345 +0,0 @@
-/* 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

@@ -1,12 +0,0 @@
-/* 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

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

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

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

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

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

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