@fc3/mmcadi 0.1.0 → 0.1.1

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

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

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

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

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

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

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