@fc3/mmcadi 0.1.0

package/src/lib/http/transaction.ts

@@ -0,0 +1,320 @@
+/**
+ * This is a base class that represents the common interface between the
+ * following HTTP transaction types:
+ *   - incoming requests
+ *   - outgoing responses
+ *   - outgoing requests
+ *   - incoming responses
+ *
+ * This class is useful as a means of consolidating the common logic between
+ * these four transaction types. Things such as HTTP headers, status codes,
+ * connection state, and so on.
+ */
+
+import Logger, {LogLevel} from 'lib/logger';
+import {ConnectionStatus} from 'lib/network';
+import ExecutionContext from 'lib/execution-context';
+import {InvariantViolation} from 'lib/errors';
+import {isBrowser} from 'lib/environment';
+import {StringEncoding} from 'lib/string';
+import {Dispatcher, TagMap} from 'lib/metrics';
+
+import HeaderMap from 'lib/http/type/header-map';
+import HttpMethod from 'lib/http/enum/method';
+import HttpHeader from 'lib/http/enum/header';
+import ContentType from 'lib/http/enum/content-type';
+import LogAttributes from 'lib/http/type/log-attributes';
+import TransactionData from 'lib/http/type/transaction-data';
+
+abstract class Transaction {
+	private execution_context: ExecutionContext | undefined;
+	private path: string;
+	private data: TransactionData | undefined;
+	private headers: HeaderMap | undefined;
+	private method: HttpMethod;
+	private body: Buffer;
+	private connection_status: ConnectionStatus;
+	private start_time: number;
+	private end_time: number | undefined;
+	private logging_disabled: boolean;
+
+	public constructor(execution_context?: ExecutionContext) {
+		this.execution_context = execution_context;
+		this.path = '/';
+		this.method = HttpMethod.GET;
+		this.start_time = Date.now();
+		this.body = Buffer.from('');
+		this.logging_disabled = false;
+		this.connection_status = ConnectionStatus.DISCONNECTED;
+	}
+
+	public setPath(path: string): this {
+		this.path = path;
+		return this;
+	}
+
+	public getPath(): string {
+		return this.path;
+	}
+
+	public setData(data: TransactionData): this {
+		this.data = data;
+		return this;
+	}
+
+	public setBody(body: Buffer): this {
+		this.body = body;
+		return this;
+	}
+
+	public getBody(): Buffer {
+		if (!this.hasBody() && this.hasData()) {
+			const data = this.getData();
+			const serialized_data = JSON.stringify(data);
+
+			this.body = Buffer.from(serialized_data);
+		}
+
+		return this.body;
+	}
+
+	public setHeaders(headers: HeaderMap): this {
+		this.headers = headers;
+		return this;
+	}
+
+	public getHeaders(): HeaderMap {
+		if (this.headers === undefined) {
+			this.headers = {} as HeaderMap;
+		}
+
+		return this.headers;
+	}
+
+	public getContentType(): ContentType | void {
+		const header_value = this.getHeaderValue(HttpHeader.CONTENT_TYPE);
+
+		if (!header_value) {
+			return undefined;
+		}
+
+		return this.stripHeaderParameter(header_value) as ContentType;
+	}
+
+	public setContentType(content_type: ContentType): this {
+		this.setHeaderValue(HttpHeader.CONTENT_TYPE, content_type);
+		return this;
+	}
+
+	public getHeaderValue(key: HttpHeader): string | undefined {
+		return this.getHeaders()[key];
+	}
+
+	public setHeaderValue(key: HttpHeader, value: string | number): this {
+		if (typeof value === 'number') {
+			value = value.toString();
+		}
+
+		const headers = this.getHeaders();
+
+		headers[key] = value;
+
+		return this;
+	}
+
+	public setMethod(method: HttpMethod): this {
+		this.method = method;
+		return this;
+	}
+
+	public getMethod(): HttpMethod {
+		return this.method;
+	}
+
+	public getConnectionStatus(): ConnectionStatus {
+		return this.connection_status;
+	}
+
+	public setConnectionStatus(connection_status: ConnectionStatus): this {
+		this.connection_status = connection_status;
+		return this;
+	}
+
+	public getRequestId(): string {
+		const execution_context = this.getExecutionContext();
+
+		return execution_context.getUniqueId();
+	}
+
+	public log(): void {
+		if (this.loggingIsDisabled()) {
+			return;
+		}
+
+		const logger = this.getLogger();
+
+		logger.writeMessage(this.getLogMessage(), this.getLogLevel());
+	}
+
+	public getLogger(): Logger {
+		return this.getExecutionContext().getLogger();
+	}
+
+	public getExecutionContext(): ExecutionContext {
+		if (this.execution_context === undefined) {
+			throw new InvariantViolation(`
+				Tried to read execution context, but it was not set
+			`);
+		}
+
+		return this.execution_context;
+	}
+
+	public setExecutionContext(execution_context: ExecutionContext): this {
+		this.execution_context = execution_context;
+		return this;
+	}
+
+	public disableLogging(): this {
+		this.logging_disabled = true;
+		return this;
+	}
+
+	public getData(): TransactionData {
+		if (this.data === undefined) {
+			throw new Error('Tried to read data, but it was not set');
+		}
+
+		return this.data;
+	}
+
+	protected hasData(): boolean {
+		return this.data !== undefined;
+	}
+
+	protected hasBody(): boolean {
+		return this.body.length > 0;
+	}
+
+	protected getBodyAsString(): string {
+		const body = this.getBody();
+
+		return body.toString(StringEncoding.UTF8);
+	}
+
+	protected appendToBody(data: Buffer): void {
+		this.body = Buffer.concat([this.body, data]);
+	}
+
+	protected hasHeaderValue(key: HttpHeader): boolean {
+		return this.getHeaderValue(key) !== undefined;
+	}
+
+	protected createExecutionContext(): ExecutionContext {
+		throw new Error(
+			`Tried to create request context in non-request class: ${this.constructor.name}`
+		);
+	}
+
+	protected getDuration(): number {
+		if (this.hasEnded()) {
+			return this.getEndTime() - this.getStartTime();
+		}
+
+		return Date.now() - this.getStartTime();
+	}
+
+	protected hasEnded(): boolean {
+		return this.end_time !== undefined;
+	}
+
+	protected end(): void {
+		this.markEndTime();
+		this.log();
+		this.dispatchMetrics();
+	}
+
+	protected getSanitizedPath(): string {
+		const path = this.getPath();
+
+		return path.replace(/(secret|code)=([^&]+)/g, (_match, parameter) => {
+			return `${parameter}=REDACTED`;
+		});
+	}
+
+	protected loggingIsDisabled(): boolean {
+		return this.logging_disabled;
+	}
+
+	private dispatchMetrics(): void {
+		if (isBrowser()) {
+			return;
+		}
+
+		this.dispatchCountMetric();
+		this.dispatchTimingMetric();
+	}
+
+	private dispatchCountMetric(): void {
+		const dispatcher = Dispatcher.getInstance();
+		const metric_name = this.getCountMetricName();
+		const metric_tags = this.getMetricTags();
+
+		dispatcher.increment(metric_name, 1, metric_tags);
+	}
+
+	private dispatchTimingMetric(): void {
+		const dispatcher = Dispatcher.getInstance();
+		const metric_name = this.getTimingMetricName();
+		const duration = this.getDuration();
+		const metric_tags = this.getMetricTags();
+
+		dispatcher.timing(metric_name, duration, metric_tags);
+	}
+
+	private getLogMessage(): string {
+		const log_attributes = this.getLogAttributes();
+
+		let message = `${log_attributes.http_method} ${log_attributes.path}`;
+
+		if (log_attributes.status_code) {
+			message = `[${log_attributes.status_code}] ${message}`;
+		}
+
+		return message;
+	}
+
+	private stripHeaderParameter(header_value: string): string {
+		const parts = header_value.split(';');
+
+		if (parts[0]) {
+			return parts[0];
+		}
+
+		return header_value;
+	}
+
+	private markEndTime(): void {
+		this.end_time = Date.now();
+	}
+
+	private getStartTime(): number {
+		return this.start_time;
+	}
+
+	private getEndTime(): number {
+		if (this.end_time === undefined) {
+			throw new Error('Tried to read end time, but it was not set');
+		}
+
+		return this.end_time;
+	}
+
+	protected abstract getLogAttributes(): LogAttributes;
+	protected abstract getLogLevel(): LogLevel;
+	protected abstract getMetricTags(): TagMap;
+	protected abstract getCountMetricName(): string;
+	protected abstract getTimingMetricName(): string;
+}
+
+export default Transaction;

package/src/lib/http/type/basic-auth-credentials.ts

@@ -0,0 +1,6 @@
+interface BasicAuthCredentials {
+	username: string;
+	password: string;
+}
+
+export default BasicAuthCredentials;

package/src/lib/http/type/header-map.ts

@@ -0,0 +1,5 @@
+interface HeaderMap {
+	[key: string]: string;
+}
+
+export default HeaderMap;

package/src/lib/http/type/log-attributes.ts

@@ -0,0 +1,12 @@
+import Method from 'lib/http/enum/method';
+import StatusCode from 'lib/http/enum/status-code';
+
+interface LogAttributes {
+	readonly class_name: string;
+	readonly status_code?: StatusCode;
+	readonly http_method: Method;
+	readonly path: string;
+	readonly body: string;
+}
+
+export default LogAttributes;

package/src/lib/http/type/path-parameters.ts

@@ -0,0 +1,5 @@
+interface PathParameters {
+	[key: string]: string;
+}
+
+export default PathParameters;

package/src/lib/http/type/query-data.ts

@@ -0,0 +1,7 @@
+import QueryValue from 'lib/http/type/query-value';
+
+interface QueryData {
+	[key: string]: QueryValue;
+}
+
+export default QueryData;

package/src/lib/http/type/query-value.ts

@@ -0,0 +1,11 @@
+type QueryValue =
+	| string
+	| number
+	| boolean
+	| readonly string[]
+	| readonly number[]
+	| readonly boolean[]
+	| null
+	| undefined;
+
+export default QueryValue;

package/src/lib/http/type/request-options.ts

@@ -0,0 +1,16 @@
+import Method from 'lib/http/enum/method';
+import HeaderMap from 'lib/http/type/header-map';
+
+interface RequestOptions {
+	// TODO: Should we use a more restrictive string union type (http: | https:)?
+	protocol: string;
+	hostname: string;
+	port: number;
+	path: string;
+	method: Method;
+	headers: HeaderMap;
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	rejectUnauthorized?: boolean;
+}
+
+export default RequestOptions;

package/src/lib/http/type/transaction-data.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type TransactionData = Record<string, unknown> | Array<unknown>;
+
+export default TransactionData;

package/src/lib/http/utility/get-content-type-for-extension.ts

@@ -0,0 +1,47 @@
+import {InvalidError} from 'lib/errors';
+import {FileExtension} from 'lib/filesystem';
+
+import ContentType from 'lib/http/enum/content-type';
+
+function getContentTypeForExtension(extension: FileExtension): ContentType {
+	switch (extension) {
+		case FileExtension.CSS:
+			return ContentType.CSS;
+
+		case FileExtension.GIF:
+			return ContentType.GIF;
+
+		case FileExtension.HTML:
+			return ContentType.HTML;
+
+		case FileExtension.ICO:
+			return ContentType.ICO;
+
+		case FileExtension.JPEG:
+		case FileExtension.JPG:
+			return ContentType.JPEG;
+
+		case FileExtension.JS:
+			return ContentType.JS;
+
+		case FileExtension.JSON:
+			return ContentType.JSON;
+
+		case FileExtension.MP3:
+			return ContentType.MP3;
+
+		case FileExtension.PNG:
+			return ContentType.PNG;
+
+		case FileExtension.TXT:
+			return ContentType.TEXT;
+
+		case FileExtension.WAV:
+			return ContentType.WAV;
+
+		default:
+			throw new InvalidError(`Unsupported file extension: ${extension}`);
+	}
+}
+
+export default getContentTypeForExtension;

package/src/lib/http/utility/get-library-for-protocol.ts

@@ -0,0 +1,25 @@
+import HTTP from 'http';
+import HTTPS from 'https';
+
+import {isBrowser} from 'lib/environment';
+import {NetworkProtocol} from 'lib/network';
+
+import IsomorphicHttp from 'lib/http/isomorphic';
+import NetworkLibrary from 'lib/http/interface/network-library';
+
+function getLibraryForProtocol(protocol: NetworkProtocol): NetworkLibrary {
+	if (isBrowser()) {
+		return new IsomorphicHttp();
+	}
+
+	switch (protocol) {
+		case NetworkProtocol.HTTP:
+			return HTTP;
+		case NetworkProtocol.HTTPS:
+			return HTTPS;
+		default:
+			throw new Error(`Unsupported network protocol: ${protocol}`);
+	}
+}
+
+export default getLibraryForProtocol;

package/src/lib/http/utility/get-status-code-for-error-type.ts

@@ -0,0 +1,37 @@
+import {ErrorType, GenericError} from 'lib/errors';
+
+import StatusCode from 'lib/http/enum/status-code';
+
+function getStatusCodeForErrorType(error_code: ErrorType): StatusCode {
+	switch (error_code) {
+		case ErrorType.CONFLICT:
+			return StatusCode.CONFLICT;
+
+		case ErrorType.GENERIC:
+			return StatusCode.SERVER_ERROR;
+
+		case ErrorType.INVALID:
+		case ErrorType.OMITTED:
+			return StatusCode.BAD_REQUEST;
+
+		case ErrorType.NOT_FOUND:
+			return StatusCode.FILE_NOT_FOUND;
+
+		case ErrorType.NOT_ALLOWED:
+			return StatusCode.METHOD_NOT_ALLOWED;
+
+		case ErrorType.NOT_IMPLEMENTED:
+			return StatusCode.NOT_IMPLEMENTED;
+
+		case ErrorType.TIMEOUT:
+			return StatusCode.REQUEST_TIMEOUT;
+
+		case ErrorType.UNAUTHORIZED:
+			return StatusCode.UNAUTHORIZED;
+
+		default:
+			throw new GenericError(`Unsupported error code: ${error_code}`);
+	}
+}
+
+export default getStatusCodeForErrorType;

package/src/lib/http/utility/get-status-code-for-error.ts

@@ -0,0 +1,13 @@
+import {wrapError} from 'lib/errors';
+
+import StatusCode from 'lib/http/enum/status-code';
+import getStatusCodeForErrorType from 'lib/http/utility/get-status-code-for-error-type';
+
+function getStatusCodeForError(error: Error): StatusCode {
+	const wrapped_error = wrapError(error);
+	const error_type = wrapped_error.getType();
+
+	return getStatusCodeForErrorType(error_type);
+}
+
+export default getStatusCodeForError;

package/src/lib/http/utility/is-client-error-status.ts

@@ -0,0 +1,15 @@
+import StatusCode from 'lib/http/enum/status-code';
+
+function isClientErrorStatus(status_code: StatusCode): boolean {
+	if (status_code < StatusCode.BAD_REQUEST) {
+		return false;
+	}
+
+	if (status_code >= StatusCode.SERVER_ERROR) {
+		return false;
+	}
+
+	return true;
+}
+
+export default isClientErrorStatus;

package/src/lib/http/utility/is-error-status.ts

@@ -0,0 +1,9 @@
+import StatusCode from 'lib/http/enum/status-code';
+import isClientErrorStatus from 'lib/http/utility/is-client-error-status';
+import isServerErrorStatus from 'lib/http/utility/is-server-error-status';
+
+function isErrorStatus(status_code: StatusCode): boolean {
+	return isClientErrorStatus(status_code) || isServerErrorStatus(status_code);
+}
+
+export default isErrorStatus;

package/src/lib/http/utility/is-server-error-status.ts

@@ -0,0 +1,7 @@
+import StatusCode from 'lib/http/enum/status-code';
+
+function isServerErrorStatus(status_code: StatusCode): boolean {
+	return status_code >= StatusCode.SERVER_ERROR;
+}
+
+export default isServerErrorStatus;

package/src/lib/http/utility/is-success-status.ts

@@ -0,0 +1,7 @@
+import StatusCode from 'lib/http/enum/status-code';
+
+function isSuccessStatus(status_code: StatusCode): boolean {
+	return status_code <= StatusCode.PARTIAL_CONTENT;
+}
+
+export default isSuccessStatus;

package/src/lib/http/utility/proxy-request.ts

@@ -0,0 +1,58 @@
+import HTTP from 'http';
+
+import Logger from 'lib/logger';
+import PromiseWrapper from 'lib/promise-wrapper';
+import {NetworkProtocol} from 'lib/network';
+
+import StatusCode from 'lib/http/enum/status-code';
+import RequestOptions from 'lib/http/type/request-options';
+import getLibraryForProtocol from 'lib/http/utility/get-library-for-protocol';
+import serializeRequestOptions from 'lib/http/utility/serialize-request-options';
+
+async function proxyRequest(
+	protocol: NetworkProtocol,
+	options: RequestOptions,
+	request: HTTP.IncomingMessage,
+	response: HTTP.ServerResponse
+): Promise<void> {
+	const promise_wrapper = new PromiseWrapper();
+	const library = getLibraryForProtocol(protocol);
+
+	const proxy_request = library.request(options, (raw_response) => {
+		const proxy_response = raw_response as HTTP.IncomingMessage;
+		const status_code = proxy_response.statusCode || StatusCode.SUCCESS;
+
+		response.writeHead(status_code, proxy_response.headers);
+
+		proxy_response.on('data', (data) => {
+			response.write(data);
+		});
+
+		proxy_response.on('end', () => {
+			response.end();
+			promise_wrapper.resolve();
+		});
+		// TODO: Remove the need to cast here (and the response above) by
+		// implementing the remaining stuff on the IsomorphicRequest class.
+	}) as HTTP.ClientRequest;
+
+	request.pipe(proxy_request, {
+		end: true
+	});
+
+	proxy_request.on('error', (error) => {
+		const logger = new Logger();
+		const serialized_options = serializeRequestOptions(options);
+
+		logger.warn(`
+			Received error when proxying request: ${serialized_options}:
+			${error.message}
+		`);
+
+		return promise_wrapper.reject(error);
+	});
+
+	await promise_wrapper.getPromise();
+}
+
+export default proxyRequest;

package/src/lib/http/utility/serialize-request-options.ts

@@ -0,0 +1,9 @@
+import RequestOptions from 'lib/http/type/request-options';
+
+function serializeRequestOptions(options: RequestOptions): string {
+	const {method, protocol, hostname, port, path} = options;
+
+	return `${method} ${protocol}//${hostname}:${port}${path}`;
+}
+
+export default serializeRequestOptions;

package/src/lib/http/utility/slug-generator.ts

@@ -0,0 +1,20 @@
+class SlugGenerator {
+	private message: string;
+
+	public constructor(message: string) {
+		this.message = message;
+	}
+
+	public generate(): string {
+		return this.getMessage()
+			.replace(/\s/g, '-')
+			.replace(/[^A-Za-z0-9-]/g, '')
+			.toLowerCase();
+	}
+
+	private getMessage(): string {
+		return this.message;
+	}
+}
+
+export default SlugGenerator;

package/src/lib/key-generator/index.ts

@@ -0,0 +1,3 @@
+import KeyGenerator from 'lib/key-generator/key-generator';
+
+export default KeyGenerator;

package/src/lib/key-generator/key-generator.ts

@@ -0,0 +1,7 @@
+class KeyGenerator {
+	public static generateToken(): string {
+		return Math.random().toString(16).slice(2);
+	}
+}
+
+export default KeyGenerator;

package/src/lib/logger/enum/ansi-escape-code.ts

@@ -0,0 +1,14 @@
+enum AnsiEscapeCode {
+	BLACK = '\x1b[30m',
+	RED = '\x1b[31m',
+	GREEN = '\x1b[32m',
+	YELLOW = '\x1b[33m',
+	BLUE = '\x1b[34m',
+	MAGENTA = '\x1b[35m',
+	CYAN = '\x1b[36m',
+	WHITE = '\x1b[37m',
+	GREY = '\x1b[38m',
+	RESET = '\x1b[39;49m'
+}
+
+export default AnsiEscapeCode;