@fc3/mmcadi 0.1.0

package/src/lib/http/response/incoming.ts

@@ -0,0 +1,243 @@
+import PromiseWrapper from 'lib/promise-wrapper';
+
+import {
+	InvariantViolation,
+	InvalidError,
+	createErrorFromAmbiguousJsonData
+} from 'lib/errors';
+
+import {isBrowser} from 'lib/environment';
+import {TagMap} from 'lib/metrics';
+
+import Response from 'lib/http/response';
+import HeaderMap from 'lib/http/type/header-map';
+import StatusCode from 'lib/http/enum/status-code';
+import ContentType from 'lib/http/enum/content-type';
+import BufferStream from 'lib/http/buffer-stream';
+import IncomingMessage from 'lib/http/interface/incoming-message';
+
+class IncomingResponse extends Response {
+	private native_response: IncomingMessage | undefined;
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	private promise_wrapper: PromiseWrapper<object> | undefined;
+	private stream: BufferStream | undefined;
+	private url: string | undefined;
+
+	public constructor() {
+		super();
+
+		this.bindHandlers();
+	}
+
+	public setNativeResponse(native_response: IncomingMessage): void {
+		this.native_response = native_response;
+
+		this.setStatusCode(native_response.statusCode as StatusCode);
+		this.setHeaders(native_response.headers as HeaderMap);
+
+		this.assignHandlers();
+	}
+
+	public setUrl(url: string): this {
+		this.url = url;
+
+		const parsed_url = new URL(url);
+
+		return this.setPath(parsed_url.pathname);
+	}
+
+	public getUrl(): string {
+		if (this.url === undefined) {
+			throw new Error('Tried to read url, but it was not set');
+		}
+
+		return this.url;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public getPromise(): Promise<object> {
+		const promise_wrapper = this.getPromiseWrapper();
+
+		return promise_wrapper.getPromise();
+	}
+
+	public getStream(): BufferStream {
+		if (this.stream !== undefined) {
+			return this.stream;
+		}
+
+		if (isBrowser()) {
+			throw new InvariantViolation('Tried to create buffer stream in browser');
+		}
+
+		this.stream = new BufferStream();
+
+		return this.stream;
+	}
+
+	public getNativeResponse(): IncomingMessage {
+		if (this.native_response === undefined) {
+			throw new Error('Tried to read native response, but it was not set');
+		}
+
+		return this.native_response;
+	}
+
+	protected getCountMetricName(): string {
+		return 'incoming_responses';
+	}
+
+	protected getTimingMetricName(): string {
+		return 'incoming_response_time';
+	}
+
+	protected getMetricTags(): TagMap {
+		return {
+			status: this.getStatusCode()
+		};
+	}
+
+	private bindHandlers(): void {
+		this.handleResponseData = this.handleResponseData.bind(this);
+		this.handleResponseEnd = this.handleResponseEnd.bind(this);
+		this.handleResponseError = this.handleResponseError.bind(this);
+	}
+
+	private assignHandlers(): void {
+		const native_response = this.getNativeResponse();
+
+		native_response.on('data', this.handleResponseData);
+		native_response.on('end', this.handleResponseEnd);
+		native_response.on('error', this.handleResponseError);
+	}
+
+	private handleResponseData(data: Buffer): void {
+		if (this.isStreaming() && !this.hasErrorStatus()) {
+			this.appendToStream(data);
+		} else {
+			this.appendToBody(data);
+		}
+	}
+
+	private appendToStream(data: Buffer): void {
+		const stream = this.getStream();
+
+		stream.write(data);
+	}
+
+	private handleResponseEnd(): void {
+		this.end();
+
+		if (this.isStreaming()) {
+			this.endStream();
+		}
+
+		let parsed_body;
+
+		if (this.shouldParseBody()) {
+			try {
+				parsed_body = this.parseBody();
+			} catch (error) {
+				if (!(error instanceof Error)) {
+					throw error;
+				}
+
+				const wrapped_error = new InvalidError(error.message);
+
+				return void this.rejectPromise(wrapped_error);
+			}
+		} else {
+			parsed_body = {};
+		}
+
+		if (this.hasErrorStatus()) {
+			const status_code = this.getStatusCode();
+			const error = createErrorFromAmbiguousJsonData(parsed_body, status_code);
+
+			return void this.rejectPromise(error);
+		}
+
+		return void this.fulfillPromise(parsed_body);
+	}
+
+	private endStream(): void {
+		const stream = this.getStream();
+
+		stream.end();
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	private parseBody(): object {
+		const body_string = this.getBodyAsString();
+
+		return JSON.parse(body_string);
+	}
+
+	private hasEmptyBody(): boolean {
+		return this.getBody().length === 0;
+	}
+
+	private shouldParseBody(): boolean {
+		if (this.isStreaming() && !this.hasErrorStatus()) {
+			return false;
+		}
+
+		const content_type = this.getContentType();
+
+		if (content_type !== ContentType.JSON) {
+			return false;
+		}
+
+		if (this.wasRedirected()) {
+			return false;
+		}
+
+		if (this.hasEmptyBody()) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private wasRedirected(): boolean {
+		const status_code = this.getStatusCode();
+
+		return (
+			status_code >= StatusCode.MULTIPLE_CHOICES &&
+			status_code <= StatusCode.PERMANENT_REDIRECT
+		);
+	}
+
+	private handleResponseError(error: Error): void {
+		this.rejectPromise(error);
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	private fulfillPromise(result: object): void {
+		const promise_wrapper = this.getPromiseWrapper();
+
+		promise_wrapper.resolve(result);
+	}
+
+	private rejectPromise(error: Error): void {
+		const promise_wrapper = this.getPromiseWrapper();
+
+		promise_wrapper.reject(error);
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	private getPromiseWrapper(): PromiseWrapper<object> {
+		if (this.promise_wrapper === undefined) {
+			// eslint-disable-next-line @typescript-eslint/ban-types
+			this.promise_wrapper = new PromiseWrapper<object>();
+		}
+
+		return this.promise_wrapper;
+	}
+
+	private isStreaming(): boolean {
+		return this.stream !== undefined;
+	}
+}
+
+export default IncomingResponse;

package/src/lib/http/response/outgoing.ts

@@ -0,0 +1,160 @@
+import HTTP from 'http';
+
+import {StringEncoding} from 'lib/string';
+import {wrapError} from 'lib/errors';
+import {TagMap} from 'lib/metrics';
+
+import Response from 'lib/http/response';
+import HttpHeader from 'lib/http/enum/header';
+import StatusCode from 'lib/http/enum/status-code';
+import ContentType from 'lib/http/enum/content-type';
+import getStatusCodeForErrorType from 'lib/http/utility/get-status-code-for-error-type';
+
+class OutgoingResponse extends Response {
+	private native_response: HTTP.ServerResponse;
+
+	public constructor(native_response: HTTP.ServerResponse) {
+		super();
+
+		this.native_response = native_response;
+		this.bindHandlers();
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public sendPromise(promise: Promise<object | string | Buffer>): void {
+		promise.then(this.send).catch(this.error);
+	}
+
+	public render(body: string): void {
+		this.setHeaderValue(HttpHeader.CONTENT_TYPE, ContentType.HTML);
+		this.sendString(body);
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public send(body: object | string | Buffer): void {
+		if (typeof body === 'string') {
+			this.sendString(body);
+		} else if (body instanceof Buffer) {
+			this.sendBuffer(body);
+		} else {
+			this.sendObject(body);
+		}
+	}
+
+	public error(error: Error): void {
+		const wrapped_error = wrapError(error);
+
+		this.getLogger().error(wrapped_error);
+
+		const error_type = wrapped_error.getType();
+		const status_code = getStatusCodeForErrorType(error_type);
+		const error_data = wrapped_error.getData();
+
+		this.setStatusCode(status_code);
+		this.send(error_data);
+	}
+
+	public redirectToUrl(url: string): void {
+		this.setHeaderValue(HttpHeader.LOCATION, url);
+		this.setStatusCode(StatusCode.REDIRECT);
+		this.send('');
+	}
+
+	public setHeaderValue(key: HttpHeader, value: string | number): this {
+		const native_response = this.getNativeResponse();
+
+		if (key === HttpHeader.CONTENT_TYPE) {
+			switch (value) {
+				case ContentType.HTML:
+				case ContentType.TEXT:
+				case ContentType.JSON:
+					value = `${value}; charset=UTF-8`;
+					break;
+			}
+		}
+
+		native_response.setHeader(key, value);
+
+		return super.setHeaderValue(key, value);
+	}
+
+	public setStatusCode(status_code: StatusCode): this {
+		const native_response = this.getNativeResponse();
+
+		native_response.statusCode = status_code;
+
+		return super.setStatusCode(status_code);
+	}
+
+	public getNativeResponse(): HTTP.ServerResponse {
+		return this.native_response;
+	}
+
+	protected getCountMetricName(): string {
+		return 'outgoing_responses';
+	}
+
+	protected getTimingMetricName(): string {
+		return 'outgoing_response_time';
+	}
+
+	protected getMetricTags(): TagMap {
+		return {
+			status: this.getStatusCode(),
+			endpoint: 'UPDATE ME'
+		};
+	}
+
+	/**
+	 * Overwrite the parent class's end() implementation in order to first
+	 * forward along the response body to the underlying native response.
+	 */
+	protected end(): void {
+		const native_response = this.getNativeResponse();
+		const body = this.getBody();
+
+		// TODO: Add validation ensuring that the response body is empty
+		// if a 204 NO CONTENT response status code has been assigned.
+
+		native_response.end(body);
+
+		super.end();
+	}
+
+	private bindHandlers(): void {
+		this.error = this.error.bind(this);
+		this.send = this.send.bind(this);
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	private sendObject(body_object: object): void {
+		const body_string = JSON.stringify(body_object);
+
+		if (!this.hasHeaderValue(HttpHeader.CONTENT_TYPE)) {
+			this.setHeaderValue(HttpHeader.CONTENT_TYPE, ContentType.JSON);
+		}
+
+		this.sendString(body_string);
+	}
+
+	private sendString(body_string: string): void {
+		if (!this.hasHeaderValue(HttpHeader.CONTENT_TYPE)) {
+			this.setHeaderValue(HttpHeader.CONTENT_TYPE, ContentType.TEXT);
+		}
+
+		const body_buffer = Buffer.from(body_string, StringEncoding.UTF8);
+
+		return this.sendBuffer(body_buffer);
+	}
+
+	private sendBuffer(body_buffer: Buffer): void {
+		const byte_length = body_buffer.length;
+
+		this.setHeaderValue(HttpHeader.CONTENT_LENGTH, byte_length);
+		this.setBody(body_buffer);
+
+		this.end();
+	}
+}
+
+export default OutgoingResponse;

package/src/lib/http/response.ts

@@ -0,0 +1,74 @@
+import {LogLevel} from 'lib/logger';
+
+import StatusCode from 'lib/http/enum/status-code';
+import Transaction from 'lib/http/transaction';
+import LogAttributes from 'lib/http/type/log-attributes';
+import isErrorStatus from 'lib/http/utility/is-error-status';
+import isSuccessStatus from 'lib/http/utility/is-success-status';
+import isServerErrorStatus from 'lib/http/utility/is-server-error-status';
+import isClientErrorStatus from 'lib/http/utility/is-client-error-status';
+
+abstract class HttpResponse extends Transaction {
+	private status_code: StatusCode = StatusCode.SUCCESS;
+
+	public getStatusCode(): StatusCode {
+		return this.status_code;
+	}
+
+	public setStatusCode(status_code: StatusCode): this {
+		this.status_code = status_code;
+		return this;
+	}
+
+	protected hasErrorStatus(): boolean {
+		const status_code = this.getStatusCode();
+
+		return isErrorStatus(status_code);
+	}
+
+	protected getLogAttributes(): LogAttributes {
+		return {
+			class_name: this.constructor.name,
+			status_code: this.getStatusCode(),
+			http_method: this.getMethod(),
+			path: this.getSanitizedPath(),
+			body: this.getBodyAsString()
+		};
+	}
+
+	protected getLogLevel(): LogLevel {
+		if (this.hasServerErrorStatus()) {
+			return LogLevel.ERROR;
+		}
+
+		if (this.hasClientErrorStatus()) {
+			return LogLevel.WARNING;
+		}
+
+		if (this.hasSuccessStatus()) {
+			return LogLevel.SUCCESS;
+		}
+
+		return LogLevel.INFO;
+	}
+
+	private hasServerErrorStatus(): boolean {
+		const status_code = this.getStatusCode();
+
+		return isServerErrorStatus(status_code);
+	}
+
+	private hasClientErrorStatus(): boolean {
+		const status_code = this.getStatusCode();
+
+		return isClientErrorStatus(status_code);
+	}
+
+	private hasSuccessStatus(): boolean {
+		const status_code = this.getStatusCode();
+
+		return isSuccessStatus(status_code);
+	}
+}
+
+export default HttpResponse;

package/src/lib/http/serializer/basic-auth-header.ts

@@ -0,0 +1,27 @@
+import {StringEncoding} from 'lib/string';
+
+import BasicAuthCredentials from 'lib/http/type/basic-auth-credentials';
+
+class BasicAuthHeaderSerializer {
+	private credentials: BasicAuthCredentials;
+
+	public constructor(credentials: BasicAuthCredentials) {
+		this.credentials = credentials;
+	}
+
+	public serialize(): string {
+		const credentials = this.getCredentials();
+
+		const input = `${credentials.username}:${credentials.password}`;
+		const buffer = Buffer.from(input);
+		const base64 = buffer.toString(StringEncoding.BASE64);
+
+		return `Basic ${base64}`;
+	}
+
+	private getCredentials(): BasicAuthCredentials {
+		return this.credentials;
+	}
+}
+
+export default BasicAuthHeaderSerializer;

package/src/lib/http/serializer/cookie.ts

@@ -0,0 +1,90 @@
+/**
+ * This class builds a cookie value for a given session id.
+ * The resultant cookie will be set on an outbound response back to the browser,
+ * and the browser will store it locally for reuse on subsequent requests.
+ */
+
+import {TimeInterval} from 'lib/time';
+
+import SameSitePolicy from 'lib/http/enum/same-site-policy';
+import CookieAttribute from 'lib/http/enum/cookie-attribute';
+
+class CookieSerializer {
+	private static duration = TimeInterval.ONE_MONTH;
+	private static same_site_policy = SameSitePolicy.NONE;
+
+	public static setDuration(duration: number): void {
+		this.duration = duration;
+	}
+
+	public static getDuration(): number {
+		return this.duration;
+	}
+
+	public static setSameSitePolicy(same_site_policy: SameSitePolicy): void {
+		this.same_site_policy = same_site_policy;
+	}
+
+	public static getSameSitePolicy(): SameSitePolicy {
+		return this.same_site_policy;
+	}
+
+	private session_id: string;
+	private domain: string | undefined;
+
+	public constructor(session_id: string, domain?: string) {
+		this.session_id = session_id;
+		this.domain = domain;
+	}
+
+	public serialize(): string {
+		const cookie_parts = [
+			`${CookieAttribute.SESSION}=${this.getSessionId()}`,
+			`${CookieAttribute.PATH}=${this.getPath()}`,
+			`${CookieAttribute.EXPIRES}=${this.getExpirationTimestamp()}`,
+			`${CookieAttribute.SAMESITE}=${this.getSameSitePolicy()}`
+		];
+
+		const domain = this.getDomain();
+
+		if (domain !== undefined) {
+			cookie_parts.push(`${CookieAttribute.DOMAIN}=${domain}`);
+		}
+
+		cookie_parts.push(CookieAttribute.HTTPONLY);
+
+		if (this.isSecure()) {
+			cookie_parts.push(CookieAttribute.SECURE);
+		}
+
+		return cookie_parts.join('; ');
+	}
+
+	private getSessionId(): string {
+		return this.session_id;
+	}
+
+	private getDomain(): string | undefined {
+		return this.domain;
+	}
+
+	private isSecure(): boolean {
+		return true;
+	}
+
+	private getPath(): string {
+		return '/';
+	}
+
+	private getExpirationTimestamp(): string {
+		const timestamp = Date.now() + CookieSerializer.getDuration();
+
+		return new Date(timestamp).toUTCString();
+	}
+
+	private getSameSitePolicy(): SameSitePolicy {
+		return CookieSerializer.getSameSitePolicy();
+	}
+}
+
+export default CookieSerializer;

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

@@ -0,0 +1,54 @@
+import {encode} from 'querystring';
+
+import QueryData from 'lib/http/type/query-data';
+import QueryValue from 'lib/http/type/query-value';
+
+class QueryDataSerializer {
+	private data: QueryData;
+
+	public constructor(data: QueryData) {
+		this.data = data;
+	}
+
+	public serialize(): string {
+		const data = this.getData();
+
+		// TODO: Probably a better way to do this "am I running in the browser"
+		// check. Can put it somewhere and recycle it; it isn't like we need the
+		// typeof check here for Typescript purposes, after all.
+		if (typeof encode === 'function') {
+			return encode(data);
+		}
+
+		const pairs: string[] = [];
+		const keys = Object.keys(data);
+
+		function append(key: string, value: QueryValue): void {
+			const encoded_value = encodeURIComponent(value as string);
+			const pair = `${key}=${encoded_value}`;
+
+			pairs.push(pair);
+		}
+
+		keys.forEach((key) => {
+			// TODO: Should we encode the value?
+			const value = data[key];
+
+			if (Array.isArray(value)) {
+				value.forEach((nested_value) => {
+					append(key, nested_value);
+				});
+			} else {
+				append(key, value);
+			}
+		});
+
+		return pairs.join('&');
+	}
+
+	private getData(): QueryData {
+		return this.data;
+	}
+}
+
+export default QueryDataSerializer;