@fc3/mmcadi 0.1.0 → 0.1.2

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

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

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

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

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