@fc3/mmcadi 0.1.0

package/src/lib/http/parser/url.ts

@@ -0,0 +1,76 @@
+import {NetworkProtocol} from 'lib/network';
+import {InvalidError} from 'lib/errors';
+
+const URL_REGEX = /^([a-z]+):\/\/([^\/]+)(.*)$/;
+
+interface ParsedUrl {
+	readonly protocol: NetworkProtocol;
+	readonly hostname: string;
+	readonly port: number;
+	readonly path: string;
+}
+
+class UrlParser {
+	private url: string;
+
+	public constructor(url: string) {
+		this.url = url;
+	}
+
+	public parse(): ParsedUrl {
+		const url = this.getUrl();
+		const match = url.match(URL_REGEX);
+
+		if (match === null) {
+			throw new InvalidError(`Unable to parse invalid url: ${url}`);
+		}
+
+		const protocol = match[1] as NetworkProtocol;
+		const prefix = match[2];
+		const path = match[3];
+
+		let hostname: string;
+		let port: number;
+
+		const colon_index = prefix.indexOf(':');
+
+		if (colon_index !== -1) {
+			hostname = prefix.slice(0, colon_index);
+
+			const raw_port = prefix.slice(colon_index + 1);
+
+			port = parseInt(raw_port);
+		} else {
+			hostname = prefix;
+			port = this.getDefaultPortForProtocol(protocol);
+		}
+
+		return {
+			protocol,
+			hostname,
+			port,
+			path
+		};
+	}
+
+	private getDefaultPortForProtocol(protocol: NetworkProtocol): number {
+		switch (protocol) {
+			case NetworkProtocol.HTTP:
+			case NetworkProtocol.WEBSOCKET:
+				return 80;
+
+			case NetworkProtocol.HTTPS:
+			case NetworkProtocol.SECURE_WEBSOCKET:
+				return 443;
+
+			default:
+				throw new InvalidError(`Unsupported protocol: ${protocol}`);
+		}
+	}
+
+	private getUrl(): string {
+		return this.url;
+	}
+}
+
+export default UrlParser;

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

@@ -0,0 +1,299 @@
+import URL from 'url';
+import HTTP from 'http';
+import {TLSSocket} from 'tls';
+import Stream from 'stream';
+
+import ExecutionContext, {Session} from 'lib/execution-context';
+import {NetworkProtocol} from 'lib/network';
+import {TagMap} from 'lib/metrics';
+
+import Request from 'lib/http/request';
+import HeaderMap from 'lib/http/type/header-map';
+import HttpHeader from 'lib/http/enum/header';
+import HttpMethod from 'lib/http/enum/method';
+import ContentType from 'lib/http/enum/content-type';
+import CookieParser from 'lib/http/parser/cookie';
+import PathParameters from 'lib/http/type/path-parameters';
+import BodyParserFactory from 'lib/http/factory/body-parser';
+
+const KNOWN_CONTENT_TYPES = Object.values(ContentType);
+
+class IncomingRequest extends Request {
+	private native_request: HTTP.IncomingMessage;
+	private path_parameters: PathParameters | undefined;
+
+	public constructor(
+		native_request: HTTP.IncomingMessage,
+		execution_context: ExecutionContext
+	) {
+		super(execution_context);
+
+		this.native_request = native_request;
+
+		const parsed_url = URL.parse(native_request.url || '/', true);
+
+		this.setPath(parsed_url.pathname as string);
+		this.setHeaders(native_request.headers as HeaderMap);
+		this.setMethod(native_request.method as HttpMethod);
+		this.updateExecutionContext();
+	}
+
+	public setPathParameters(path_parameters: PathParameters): void {
+		this.path_parameters = path_parameters;
+	}
+
+	public getProtocol(): NetworkProtocol {
+		const native_request = this.getNativeRequest();
+		const tls_socket = native_request.socket as TLSSocket;
+		const encrypted = tls_socket.encrypted;
+
+		if (encrypted) {
+			return NetworkProtocol.HTTPS;
+		} else {
+			return NetworkProtocol.HTTP;
+		}
+	}
+
+	public getOrigin(): string {
+		const origin = this.getHeaderValue(HttpHeader.ORIGIN);
+
+		return origin || '';
+	}
+
+	public getRemoteAddress(): string {
+		const forwarded_for_header = this.getHeaderValue(
+			HttpHeader.X_FORWARDED_FOR
+		);
+
+		if (forwarded_for_header) {
+			return forwarded_for_header;
+		}
+
+		const native_request = this.getNativeRequest();
+
+		return native_request.socket.remoteAddress || '<not set>';
+	}
+
+	public getAcceptedContentTypes(): ContentType[] {
+		const header_value = this.getHeaderValue(HttpHeader.ACCEPT);
+
+		if (header_value === undefined) {
+			return [ContentType.JSON];
+		}
+
+		const parts = header_value.split(',');
+		const content_types: ContentType[] = [];
+
+		parts.forEach((part) => {
+			// Trim off any trailing relative quality factor values.
+			// (See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4)
+			const subparts = part.split(';');
+			const content_type = subparts[0] as ContentType;
+
+			if (KNOWN_CONTENT_TYPES.includes(content_type)) {
+				content_types.push(content_type);
+			}
+		});
+
+		return content_types;
+	}
+
+	public hasOrigin(): boolean {
+		return this.getOrigin() !== '';
+	}
+
+	public hasParameter(key: string): boolean {
+		return this.getParameter(key) !== undefined;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	public getParameter(key: string): any {
+		if (this.hasBodyParameter(key)) {
+			return this.getBodyParameter(key);
+		}
+
+		if (this.hasPathParameter(key)) {
+			return this.getPathParameter(key);
+		}
+
+		if (this.hasQueryParameter(key)) {
+			return this.getQueryParameter(key);
+		}
+
+		return undefined;
+	}
+
+	public getQueryParameter(key: string): string | string[] | undefined {
+		const native_request = this.getNativeRequest();
+		const url_parts = URL.parse(native_request.url || '/', true);
+
+		return url_parts.query[key];
+	}
+
+	public getPathParameter(key: string): string | undefined {
+		const path_parameters = this.getPathParameters();
+
+		return path_parameters[key];
+	}
+
+	/**
+	 * We want this method to be publicly accessible, but only for this class,
+	 * as opposed to all HttpTransaction subclasses.
+	 */
+	public end(): void {
+		super.end();
+	}
+
+	public getSessionIdFromCookie(): string | undefined {
+		const cookie_header = this.getHeaderValue(HttpHeader.COOKIE);
+
+		if (!cookie_header) {
+			return undefined;
+		}
+
+		const cookie_parser = new CookieParser(cookie_header);
+
+		return cookie_parser.getSessionId();
+	}
+
+	public hasSessionIdFromCookie(): boolean {
+		return this.getSessionIdFromCookie() !== undefined;
+	}
+
+	public setSession(session: Session): this {
+		this.getExecutionContext().setSession(session);
+
+		return this;
+	}
+
+	public getSession(): Session | undefined {
+		return this.getExecutionContext().getSession();
+	}
+
+	public getStream(): Stream.Readable {
+		const native_request = this.getNativeRequest();
+
+		return native_request as Stream.Readable;
+	}
+
+	public async parseBody(): Promise<void> {
+		if (!this.hasParsableMethod()) {
+			this.setData({});
+
+			return Promise.resolve();
+		}
+
+		const stream = this.getStream();
+		const content_type = this.getContentType() || ContentType.TEXT;
+		const native_request = this.getNativeRequest();
+		const factory = new BodyParserFactory(stream, content_type, native_request);
+		const parser = factory.getParser();
+		const body = await parser.parse();
+
+		this.setData(body);
+	}
+
+	public getAllowedCorsOrigin(): string {
+		if (this.hasOrigin()) {
+			return this.getOrigin();
+		} else {
+			return 'null';
+		}
+	}
+
+	/**
+	 * When the browser makes a CORS request, it will normally request the ability
+	 * to send certain headers to the server. We should just parrot back whatever
+	 * value they request if so. However, if they *don't* explicitly request a
+	 * list of headers, we should return the ones that we think it is most likely
+	 * to send.
+	 */
+	public getAllowedCorsHeaders(): HttpHeader[] {
+		const header_string = this.getHeaderValue(
+			HttpHeader.ACCESS_CONTROL_REQUEST_HEADERS
+		);
+
+		if (header_string === undefined) {
+			return [HttpHeader.CONTENT_LENGTH, HttpHeader.CONTENT_TYPE];
+		}
+
+		const headers = header_string.split(',');
+
+		return headers as HttpHeader[];
+	}
+
+	public getNativeRequest(): HTTP.IncomingMessage {
+		return this.native_request;
+	}
+
+	protected getCountMetricName(): string {
+		return 'incoming_requests';
+	}
+
+	protected getTimingMetricName(): string {
+		return 'incoming_request_time';
+	}
+
+	protected getMetricTags(): TagMap {
+		return {
+			// TODO: yeah.
+			endpoint: 'REPLACE ME'
+		};
+	}
+
+	private hasPathParameter(key: string): boolean {
+		return this.getPathParameter(key) !== undefined;
+	}
+
+	private hasQueryParameter(key: string): boolean {
+		return this.getQueryParameter(key) !== undefined;
+	}
+
+	private hasParsableMethod(): boolean {
+		const method = this.getMethod();
+
+		switch (method) {
+			case HttpMethod.POST:
+			case HttpMethod.PUT:
+			case HttpMethod.PATCH:
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	private getBodyParameter(key: string): any {
+		if (!this.hasData()) {
+			throw new Error('Tried to read body parameter, but data was not set');
+		}
+
+		const data = this.getData();
+
+		if (Array.isArray(data)) {
+			throw new Error('Tried to read body parameter, but data was array');
+		}
+
+		return data[key];
+	}
+
+	private hasBodyParameter(key: string): boolean {
+		return this.getBodyParameter(key) !== undefined;
+	}
+
+	private getPathParameters(): PathParameters {
+		if (this.path_parameters === undefined) {
+			throw new Error('Tried to read URL parameters, but they were not set');
+		}
+
+		return this.path_parameters;
+	}
+
+	private updateExecutionContext(): void {
+		const context = this.getExecutionContext();
+
+		context.setRemoteAddress(this.getRemoteAddress());
+	}
+}
+
+export default IncomingRequest;

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

@@ -0,0 +1,276 @@
+import HTTP from 'http';
+import {URL} from 'url';
+import Stream from 'stream';
+
+import PromiseWrapper from 'lib/promise-wrapper';
+import {NetworkProtocol} from 'lib/network';
+import {InvariantViolation} from 'lib/errors';
+import ExecutionContext from 'lib/execution-context';
+import {TagMap} from 'lib/metrics';
+
+import Request from 'lib/http/request';
+import UrlParser from 'lib/http/parser/url';
+import HttpHeader from 'lib/http/enum/header';
+import HttpMethod from 'lib/http/enum/method';
+import ContentType from 'lib/http/enum/content-type';
+import ClientRequest from 'lib/http/interface/client-request';
+import RequestOptions from 'lib/http/type/request-options';
+import IncomingResponse from 'lib/http/response/incoming';
+import BasicAuthCredentials from 'lib/http/type/basic-auth-credentials';
+import getLibraryForProtocol from 'lib/http/utility/get-library-for-protocol';
+import BasicAuthHeaderSerializer from 'lib/http/serializer/basic-auth-header';
+
+class OutgoingRequest extends Request {
+	private response: IncomingResponse | undefined;
+	private sent: boolean;
+	private stream: Stream.Readable | undefined;
+	private url: string;
+
+	public constructor(url: string, execution_context: ExecutionContext) {
+		super(execution_context);
+
+		this.sent = false;
+		this.url = '';
+		this.setUrl(url);
+	}
+
+	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;
+	}
+
+	public getContentType(): ContentType {
+		const explicit_content_type = super.getContentType();
+
+		if (explicit_content_type) {
+			return explicit_content_type;
+		}
+
+		if (this.hasData()) {
+			return ContentType.JSON;
+		}
+
+		if (this.hasStream()) {
+			throw new InvariantViolation(
+				'Content type should be set when reading from stream'
+			);
+		}
+
+		return ContentType.TEXT;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public get(): Promise<object> {
+		this.setMethod(HttpMethod.GET);
+		return this.send();
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public post(): Promise<object> {
+		this.setMethod(HttpMethod.POST);
+		return this.send();
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public put(): Promise<object> {
+		this.setMethod(HttpMethod.PUT);
+		return this.send();
+	}
+
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public patch(): Promise<object> {
+		this.setMethod(HttpMethod.PATCH);
+		return this.send();
+	}
+
+	// TODO: make this private
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	public async send(): Promise<object> {
+		if (this.wasSent()) {
+			return Promise.reject(new Error('Request was already sent'));
+		}
+
+		this.sent = true;
+		this.assignHeaders();
+
+		const options = this.getOptions();
+		const response = this.getResponse();
+		const response_promise = response.getPromise();
+		const protocol = this.getProtocol();
+		const network_library = getLibraryForProtocol(protocol);
+
+		const request = network_library.request(options, (native_response) => {
+			response.setNativeResponse(native_response);
+		});
+
+		// eslint-disable-next-line @typescript-eslint/ban-types
+		const promise_wrapper = new PromiseWrapper<object>();
+
+		request.on('error', (error) => {
+			promise_wrapper.reject(error);
+		});
+
+		response_promise
+			.then((result) => {
+				promise_wrapper.resolve(result);
+			})
+			.catch((error) => {
+				promise_wrapper.reject(error);
+			});
+
+		await this.writeBody(request);
+
+		request.end();
+		this.end();
+
+		return promise_wrapper.getPromise();
+	}
+
+	public getResponse(): IncomingResponse {
+		if (this.response === undefined) {
+			this.response = this.createResponse();
+		}
+
+		return this.response;
+	}
+
+	public setBasicAuthCredentials(credentials: BasicAuthCredentials): this {
+		const serializer = new BasicAuthHeaderSerializer(credentials);
+		const header_value = serializer.serialize();
+
+		this.setHeaderValue(HttpHeader.AUTHORIZATION, header_value);
+
+		return this;
+	}
+
+	public setStream(stream: Stream.Readable, content_type: ContentType): this {
+		this.stream = stream;
+		this.setContentType(content_type);
+
+		return this;
+	}
+
+	protected getCountMetricName(): string {
+		return 'outgoing_requests';
+	}
+
+	protected getTimingMetricName(): string {
+		return 'outgoing_request_time';
+	}
+
+	protected getMetricTags(): TagMap {
+		return {};
+	}
+
+	private wasSent(): boolean {
+		return this.sent;
+	}
+
+	private getProtocol(): NetworkProtocol {
+		const url = this.getUrl();
+		const index = url.indexOf('://');
+
+		if (index === -1) {
+			throw new Error(`Unable to determine protocol for url: ${url}`);
+		}
+
+		const prefix = url.slice(0, index);
+
+		return prefix as NetworkProtocol;
+	}
+
+	private assignHeaders(): void {
+		if (!this.hasHeaderValue(HttpHeader.CONTENT_LENGTH) && !this.hasStream()) {
+			this.setHeaderValue(HttpHeader.CONTENT_LENGTH, this.getContentLength());
+		}
+
+		if (!this.hasHeaderValue(HttpHeader.CONTENT_TYPE)) {
+			this.setHeaderValue(HttpHeader.CONTENT_TYPE, this.getContentType());
+		}
+	}
+
+	private getContentLength(): number {
+		return Buffer.byteLength(this.getBody());
+	}
+
+	private getOptions(): RequestOptions {
+		const url = this.getUrl();
+		const parser = new UrlParser(url);
+		const parsed_url = parser.parse();
+
+		// TODO: Verify that the parsed protocol matches this.getProtocol() maybe?
+
+		return {
+			// Node requires that the protocol end with a trailing colon:
+			protocol: `${parsed_url.protocol}:`,
+			hostname: parsed_url.hostname,
+			port: parsed_url.port,
+			path: parsed_url.path,
+			method: this.getMethod(),
+			headers: this.getHeaders()
+		};
+	}
+
+	private async writeBody(request: ClientRequest): Promise<void> {
+		if (this.hasBody()) {
+			request.write(this.getBody());
+
+			return Promise.resolve();
+		}
+
+		const stream = this.getStream();
+
+		if (stream === undefined) {
+			return Promise.resolve();
+		}
+
+		const promise_wrapper = new PromiseWrapper<void>();
+		const cast_request = request as HTTP.ClientRequest;
+		const cast_stream = stream;
+
+		// cast_stream.pipe(cast_request);
+		cast_stream.on('data', (data) => {
+			cast_request.write(data);
+		});
+
+		cast_stream.on('end', () => {
+			promise_wrapper.resolve();
+		});
+
+		return promise_wrapper.getPromise();
+	}
+
+	private getStream(): Stream.Readable | undefined {
+		return this.stream;
+	}
+
+	private hasStream(): boolean {
+		return this.stream !== undefined;
+	}
+
+	private createResponse(): IncomingResponse {
+		const response = new IncomingResponse()
+			.setExecutionContext(this.getExecutionContext())
+			.setUrl(this.getUrl())
+			.setMethod(this.getMethod());
+
+		if (this.loggingIsDisabled()) {
+			response.disableLogging();
+		}
+
+		return response;
+	}
+}
+
+export default OutgoingRequest;

package/src/lib/http/request.ts

@@ -0,0 +1,26 @@
+import {LogLevel} from 'lib/logger';
+import ExecutionContext from 'lib/execution-context';
+
+import Transaction from 'lib/http/transaction';
+import LogAttributes from 'lib/http/type/log-attributes';
+
+abstract class Request extends Transaction {
+	public constructor(execution_context: ExecutionContext) {
+		super(execution_context);
+	}
+
+	protected getLogAttributes(): LogAttributes {
+		return {
+			class_name: this.constructor.name,
+			http_method: this.getMethod(),
+			path: this.getSanitizedPath(),
+			body: this.getBodyAsString()
+		};
+	}
+
+	protected getLogLevel(): LogLevel {
+		return LogLevel.INFO;
+	}
+}
+
+export default Request;