@fc3/mmcadi 0.1.0

package/src/lib/http/interface/client-request.ts

@@ -0,0 +1,15 @@
+// This is a stripped-down representation of HTTP.ClientRequest, which has a
+// lot of extra bells and whistles that we don't use, and which I didn't copy
+// over into the isomorphic library.
+
+interface ErrorCallback {
+	(error: Error): void;
+}
+
+interface ClientRequest {
+	on(event: 'error', callback: ErrorCallback): void;
+	write(content: Buffer): void;
+	end(): void;
+}
+
+export default ClientRequest;

package/src/lib/http/interface/incoming-message.ts

@@ -0,0 +1,24 @@
+import StatusCode from 'lib/http/enum/status-code';
+
+interface EndCallback {
+	(): void;
+}
+
+interface DataCallback {
+	(data: Buffer): void;
+}
+
+interface ErrorCallback {
+	(error: Error): void;
+}
+
+interface IncomingMessage {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	statusCode?: StatusCode;
+	headers: Record<string, string | string[] | undefined>;
+	on(event: 'end', callback: EndCallback): void;
+	on(event: 'data', callback: DataCallback): void;
+	on(event: 'error', callback: ErrorCallback): void;
+}
+
+export default IncomingMessage;

package/src/lib/http/interface/network-library.ts

@@ -0,0 +1,9 @@
+import ClientRequest from 'lib/http/interface/client-request';
+import RequestOptions from 'lib/http/type/request-options';
+import RequestCallback from 'lib/http/interface/request-callback';
+
+interface NetworkLibrary {
+	request(options: RequestOptions, callback: RequestCallback): ClientRequest;
+}
+
+export default NetworkLibrary;

package/src/lib/http/interface/request-callback.ts

@@ -0,0 +1,7 @@
+import IncomingMessage from 'lib/http/interface/incoming-message';
+
+interface RequestCallback {
+	(response: IncomingMessage): void;
+}
+
+export default RequestCallback;

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

@@ -0,0 +1,77 @@
+import {StringEncoding} from 'lib/string';
+import {EventEmitter} from 'lib/network';
+
+import HttpMethod from 'lib/http/enum/method';
+import ClientRequest from 'lib/http/interface/client-request';
+import RequestOptions from 'lib/http/type/request-options';
+import IsomorphicResponse from 'lib/http/isomorphic/response';
+
+class IsomorphicRequest extends EventEmitter implements ClientRequest {
+	private options: RequestOptions;
+	private data: Buffer;
+
+	public constructor(options: RequestOptions) {
+		super();
+
+		this.options = options;
+		this.data = Buffer.from('');
+	}
+
+	public write(content: Buffer): void {
+		this.data = Buffer.concat([this.data, content]);
+	}
+
+	public end(): void {
+		// NOTE: `protocol` should be affixed with a trailing colon already:
+		const {protocol, hostname, port, path, method, headers} = this.getOptions();
+		const url = `${protocol}//${hostname}:${port}${path}`;
+		const body = this.getBody();
+
+		const raw_request = new Request(url, {
+			method,
+			headers,
+			body
+		});
+
+		const promise = window.fetch(raw_request);
+
+		promise.then(this.handleRawResponse.bind(this));
+		promise.catch(this.handleError.bind(this));
+	}
+
+	private handleRawResponse(raw_response: Response): void {
+		const response = new IsomorphicResponse(raw_response);
+
+		this.emit('response', response);
+	}
+
+	private handleError(error: Error): void {
+		this.emit('error', error);
+	}
+
+	private getBody(): string | undefined {
+		const method = this.getMethod();
+
+		switch (method) {
+			case HttpMethod.HEAD:
+			case HttpMethod.GET:
+			case HttpMethod.DELETE:
+			case HttpMethod.OPTIONS:
+				return undefined;
+		}
+
+		return this.data.toString(StringEncoding.UTF8);
+	}
+
+	private getMethod(): HttpMethod {
+		const options = this.getOptions();
+
+		return options.method;
+	}
+
+	private getOptions(): RequestOptions {
+		return this.options;
+	}
+}
+
+export default IsomorphicRequest;

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

@@ -0,0 +1,77 @@
+import {EventEmitter} from 'lib/network';
+
+import HeaderMap from 'lib/http/type/header-map';
+import StatusCode from 'lib/http/enum/status-code';
+import IncomingMessage from 'lib/http/interface/incoming-message';
+
+function isArrayBufferSupported(): boolean {
+	if (typeof Buffer === 'undefined') {
+		return false;
+	}
+
+	const array = new Uint8Array([1]);
+	const buffer = Buffer.from(array.buffer);
+
+	return buffer[0] === 1;
+}
+
+const ARRAY_BUFFER_SUPPORTED = isArrayBufferSupported();
+
+function convertHeaders(headers: Headers): HeaderMap {
+	const result: HeaderMap = {};
+
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+
+	return result;
+}
+
+function convertArrayBuffer(array_buffer: ArrayBuffer): Buffer {
+	if (ARRAY_BUFFER_SUPPORTED) {
+		return Buffer.from(array_buffer);
+	}
+
+	const buffer = Buffer.alloc(array_buffer.byteLength);
+	const view = new Uint8Array(array_buffer);
+
+	let i = 0;
+
+	while (i < buffer.length) {
+		buffer[i] = view[i];
+		i++;
+	}
+
+	return buffer;
+}
+
+class IsomorphicResponse extends EventEmitter implements IncomingMessage {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public statusCode: StatusCode;
+	public headers: HeaderMap;
+
+	public constructor(raw_response: Response) {
+		super();
+
+		this.statusCode = raw_response.status as StatusCode;
+		this.headers = convertHeaders(raw_response.headers);
+
+		const promise = raw_response.arrayBuffer();
+
+		promise.then(this.handleEnd.bind(this));
+		promise.catch(this.handleError.bind(this));
+	}
+
+	private handleEnd(array_buffer: ArrayBuffer): void {
+		const buffer = convertArrayBuffer(array_buffer);
+
+		this.emit('data', buffer);
+		this.emit('end');
+	}
+
+	private handleError(error: Error): void {
+		this.emit('error', error);
+	}
+}
+
+export default IsomorphicResponse;

package/src/lib/http/isomorphic.ts

@@ -0,0 +1,20 @@
+import ClientRequest from 'lib/http/interface/client-request';
+import RequestOptions from 'lib/http/type/request-options';
+import NetworkLibrary from 'lib/http/interface/network-library';
+import RequestCallback from 'lib/http/interface/request-callback';
+import IsomorphicRequest from 'lib/http/isomorphic/request';
+
+class IsomorphicHttp implements NetworkLibrary {
+	public request(
+		options: RequestOptions,
+		callback: RequestCallback
+	): ClientRequest {
+		const request = new IsomorphicRequest(options);
+
+		request.on('response', callback);
+
+		return request;
+	}
+}
+
+export default IsomorphicHttp;

package/src/lib/http/parser/accept-header.ts

@@ -0,0 +1,35 @@
+import ContentType from 'lib/http/enum/content-type';
+
+class AcceptHeaderParser {
+	private accept_header: string;
+
+	public constructor(accept_header: string) {
+		this.accept_header = accept_header;
+	}
+
+	public getContentType(): ContentType {
+		const accept_header = this.getAcceptHeader();
+		const parts = accept_header.split(',');
+		const supported_content_types = Object.values(ContentType) as string[];
+
+		// TODO: Trim off trailing ';q=0.8'.
+		// Right now it doesn't really matter because most browsers specify */*
+		// as the trailing content type, and we don't match on that anyway.
+
+		const content_type = parts.find((part) => {
+			return supported_content_types.includes(part);
+		});
+
+		if (content_type === undefined) {
+			return ContentType.TEXT;
+		}
+
+		return content_type as ContentType;
+	}
+
+	private getAcceptHeader(): string {
+		return this.accept_header;
+	}
+}
+
+export default AcceptHeaderParser;

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

@@ -0,0 +1,48 @@
+import {StringEncoding} from 'lib/string';
+
+import BasicAuthCredentials from 'lib/http/type/basic-auth-credentials';
+
+class BasicAuthHeaderParser {
+	private header_value: string;
+
+	public constructor(header_value: string) {
+		this.header_value = header_value;
+	}
+
+	public parse(): BasicAuthCredentials {
+		const header_value = this.getHeaderValue();
+		const parts = header_value.split(' ');
+		const prefix = parts[0];
+
+		if (prefix !== 'Basic') {
+			throw new Error('Invalid header format');
+		}
+
+		const suffix = parts[1];
+
+		if (suffix === undefined) {
+			throw new Error('Invalid header format');
+		}
+
+		const buffer = Buffer.from(suffix, StringEncoding.BASE64);
+		const decoded_suffix = buffer.toString(StringEncoding.UTF8);
+		const suffix_parts = decoded_suffix.split(':');
+		const username = suffix_parts[0];
+		const password = suffix_parts[1];
+
+		if (username === undefined || password === undefined) {
+			throw new Error('Invalid header format');
+		}
+
+		return {
+			username,
+			password
+		};
+	}
+
+	private getHeaderValue(): string {
+		return this.header_value;
+	}
+}
+
+export default BasicAuthHeaderParser;

package/src/lib/http/parser/body/json.ts

@@ -0,0 +1,14 @@
+import {StringEncoding} from 'lib/string';
+
+import BodyParser from 'lib/http/parser/body';
+import TransactionData from 'lib/http/type/transaction-data';
+
+class JsonBodyParser extends BodyParser {
+	protected transformBuffer(buffer: Buffer): TransactionData {
+		const string_body = buffer.toString(StringEncoding.UTF8);
+
+		return JSON.parse(string_body);
+	}
+}
+
+export default JsonBodyParser;

package/src/lib/http/parser/body/multipart.ts

@@ -0,0 +1,89 @@
+import HTTP from 'http';
+import Stream from 'stream';
+
+import Formidable from 'formidable';
+
+import PromiseWrapper from 'lib/promise-wrapper';
+import {InvalidError} from 'lib/errors';
+import {getFirstValue} from 'lib/array';
+import {getExtensionForFilepath} from 'lib/filesystem';
+
+import BodyParser from 'lib/http/parser/body';
+import TransactionData from 'lib/http/type/transaction-data';
+
+class MultipartBodyParser extends BodyParser {
+	private native_request: HTTP.IncomingMessage;
+
+	public constructor(
+		stream: Stream.Readable,
+		native_request: HTTP.IncomingMessage
+	) {
+		super(stream);
+
+		this.native_request = native_request;
+	}
+
+	public async parse(): Promise<TransactionData> {
+		const native_request = this.getNativeRequest();
+
+		const form = Formidable({
+			allowEmptyFiles: true,
+			minFileSize: 0
+		});
+
+		const promise_wrapper = new PromiseWrapper<TransactionData>();
+
+		form.on('fileBegin', (_form_name, file) => {
+			// The uploadImage() utility, which is used downstream of here to
+			// upload the specified file to the assets server, requires that the
+			// source filepath have a valid file extension. However, Formidable's
+			// default behavior uploads the file to /tmp without one. So we need
+			// to tack it on ourselves (thankfully we have the means to do so here).
+
+			if (file.originalFilename === null) {
+				throw new InvalidError(`
+					Tried to read file upload name, but it was not set
+				`);
+			}
+
+			const extension = getExtensionForFilepath(file.originalFilename);
+			const new_filepath = `${file.filepath}.${extension}`;
+
+			file.filepath = new_filepath;
+		});
+
+		form.parse(native_request, (error, fields, files) => {
+			if (error) {
+				promise_wrapper.reject(error);
+				return;
+			}
+
+			const flat_fields: Record<string, string | string[] | undefined> = {};
+
+			Object.entries(fields).forEach(([key, values]) => {
+				if (values !== undefined && values.length === 1) {
+					flat_fields[key] = getFirstValue(values);
+				} else {
+					flat_fields[key] = values;
+				}
+			});
+
+			promise_wrapper.resolve({
+				...flat_fields,
+				...files
+			});
+		});
+
+		return promise_wrapper.getPromise();
+	}
+
+	protected transformBuffer(_buffer: Buffer): TransactionData {
+		throw new Error('Not implemented');
+	}
+
+	private getNativeRequest(): HTTP.IncomingMessage {
+		return this.native_request;
+	}
+}
+
+export default MultipartBodyParser;

package/src/lib/http/parser/body/url-encoded.ts

@@ -0,0 +1,16 @@
+import {StringEncoding} from 'lib/string';
+
+import BodyParser from 'lib/http/parser/body';
+import TransactionData from 'lib/http/type/transaction-data';
+import QuerystringParser from 'lib/http/parser/querystring';
+
+class UrlEncodedBodyParser extends BodyParser {
+	protected transformBuffer(buffer: Buffer): TransactionData {
+		const querystring = buffer.toString(StringEncoding.UTF8);
+		const parser = new QuerystringParser(querystring);
+
+		return parser.parse();
+	}
+}
+
+export default UrlEncodedBodyParser;

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

@@ -0,0 +1,44 @@
+import Stream from 'stream';
+
+import TransactionData from 'lib/http/type/transaction-data';
+
+abstract class BodyParser {
+	private stream: Stream.Readable;
+
+	public constructor(stream: Stream.Readable) {
+		this.stream = stream;
+	}
+
+	public async parse(): Promise<TransactionData> {
+		const buffer = await this.readBuffer();
+
+		return this.transformBuffer(buffer);
+	}
+
+	private readBuffer(): Promise<Buffer> {
+		const stream = this.getStream();
+		const chunks: Buffer[] = [];
+
+		stream.on('data', (data) => {
+			chunks.push(data);
+		});
+
+		return new Promise((resolve, reject) => {
+			stream.on('end', () => {
+				const body = Buffer.concat(chunks);
+
+				resolve(body);
+			});
+
+			stream.on('error', reject);
+		});
+	}
+
+	private getStream(): Stream.Readable {
+		return this.stream;
+	}
+
+	protected abstract transformBuffer(buffer: Buffer): TransactionData;
+}
+
+export default BodyParser;

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

@@ -0,0 +1,114 @@
+/**
+ * This class reads the cookie value supplied by the browser and parses
+ * it into its constituent pieces. The only thing we really read from it is
+ * the current user's session id.
+ */
+
+import Logger from 'lib/logger';
+
+import CookieAttribute from 'lib/http/enum/cookie-attribute';
+
+interface CookieValueMap {
+	[key: string]: string | boolean;
+}
+
+class CookieParser {
+	private header_value: string;
+	private parsed = false;
+	private cookie_values: CookieValueMap | undefined;
+
+	public constructor(header_value: string) {
+		this.header_value = header_value;
+	}
+
+	public getSessionId(): string | undefined {
+		const value = this.getValueForCookieAttribute(CookieAttribute.SESSION);
+
+		return value as string;
+	}
+
+	public getValueForCookieAttribute(
+		cookie_attribute: CookieAttribute
+	): string | boolean | undefined {
+		this.parseIfNecessary();
+
+		return this.getCookieValues()[cookie_attribute];
+	}
+
+	private parseIfNecessary(): void {
+		if (this.parsed === false) {
+			this.parse();
+		}
+	}
+
+	private parse(): void {
+		this.parsed = true;
+
+		const header_value = this.getHeaderValue();
+
+		if (!header_value) {
+			return;
+		}
+
+		const parts = header_value.split(';');
+
+		parts.forEach((part) => {
+			this.parseCookiePart(part);
+		});
+	}
+
+	private parseCookiePart(cookie_part: string): void {
+		const delimiter_index = cookie_part.indexOf('=');
+
+		let cookie_attribute;
+		let cookie_value;
+
+		if (delimiter_index === -1) {
+			cookie_attribute = cookie_part;
+			cookie_value = true;
+		} else {
+			cookie_attribute = cookie_part.slice(0, delimiter_index);
+			cookie_value = cookie_part.slice(delimiter_index + 1).trim();
+		}
+
+		cookie_attribute = cookie_attribute.trim();
+
+		if (!this.isSupportedCookieAttribute(cookie_attribute)) {
+			return void new Logger().warn(`
+				Received unsupported cookie in cookie header: ${cookie_attribute}
+			`);
+		}
+
+		return void this.setValueForCookieAttribute(
+			cookie_attribute as CookieAttribute,
+			cookie_value
+		);
+	}
+
+	private isSupportedCookieAttribute(potential_attribute: string): boolean {
+		const attributes = Object.values(CookieAttribute) as string[];
+
+		return attributes.includes(potential_attribute);
+	}
+
+	private setValueForCookieAttribute(
+		cookie_attribute: CookieAttribute,
+		value: string | boolean
+	): void {
+		this.getCookieValues()[cookie_attribute] = value;
+	}
+
+	private getCookieValues(): CookieValueMap {
+		if (!this.cookie_values) {
+			this.cookie_values = {};
+		}
+
+		return this.cookie_values;
+	}
+
+	private getHeaderValue(): string {
+		return this.header_value;
+	}
+}
+
+export default CookieParser;

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

@@ -0,0 +1,92 @@
+import Querystring from 'querystring';
+
+import TransactionData from 'lib/http/type/transaction-data';
+
+function isNumericKey(key: string): boolean {
+	const parsed_key = parseInt(key, 10);
+
+	return isNaN(parsed_key) === false;
+}
+
+function mergeValue(
+	result: Record<string, unknown>,
+	key: string,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	value: any
+): void {
+	const brace_index = key.indexOf('[');
+
+	if (brace_index === -1) {
+		result[key] = value;
+		return;
+	}
+
+	const prefix = key.slice(0, brace_index);
+	const suffix = key.slice(brace_index);
+
+	let index = 0;
+	let previous_key = prefix;
+	let current_key = '';
+	let target = result;
+
+	while (index < suffix.length) {
+		const character = suffix[index];
+
+		index++;
+
+		if (character === '[') {
+			current_key = '';
+		} else if (character === ']') {
+			if (previous_key === '') {
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				const array = (target as unknown) as any[];
+				const index_key = Math.max(0, array.length - 1);
+
+				previous_key = index_key.toString();
+			}
+
+			if (target[previous_key] === undefined) {
+				if (current_key === '' || isNumericKey(current_key)) {
+					target[previous_key] = [];
+				} else {
+					target[previous_key] = {};
+				}
+			}
+
+			target = target[previous_key] as Record<string, unknown>;
+			previous_key = current_key;
+		} else {
+			current_key += character;
+		}
+	}
+
+	target[current_key] = value;
+}
+
+class QuerystringParser {
+	private querystring: string;
+
+	public constructor(querystring: string) {
+		this.querystring = querystring;
+	}
+
+	public parse(): TransactionData {
+		const querystring = this.getQuerystring();
+		const result = {};
+		const raw_data = Querystring.parse(querystring);
+
+		Object.keys(raw_data).forEach((key) => {
+			const value = raw_data[key];
+
+			mergeValue(result, key, value);
+		});
+
+		return result;
+	}
+
+	private getQuerystring(): string {
+		return this.querystring;
+	}
+}
+
+export default QuerystringParser;