@fc3/mmcadi 0.1.0

package/src/lib/errors/utility/create-error-for-error-type.ts

@@ -0,0 +1,60 @@
+import {PosixErrorCode} from 'lib/process';
+
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+import OmittedError from 'lib/errors/error/omitted';
+import InvalidError from 'lib/errors/error/invalid';
+import TimeoutError from 'lib/errors/error/timeout';
+import GenericError from 'lib/errors/error/generic';
+import ConflictError from 'lib/errors/error/conflict';
+import NotFoundError from 'lib/errors/error/not-found';
+import NotAllowedError from 'lib/errors/error/not-allowed';
+import UnauthorizedError from 'lib/errors/error/unauthorized';
+import NotImplementedError from 'lib/errors/error/not-implemented';
+
+interface ErrorConstructor {
+	new (message: string | undefined, code: PosixErrorCode | null | undefined): BaseError;
+}
+
+function createErrorForErrorType(
+	error_type: ErrorType,
+	error_code?: PosixErrorCode | null,
+	message?: string
+): BaseError {
+	const error_constructor = getConstructorForErrorType(error_type);
+
+	return new error_constructor(message, error_code);
+}
+
+function getConstructorForErrorType(error_type: ErrorType): ErrorConstructor {
+	switch (error_type) {
+		case ErrorType.CONFLICT:
+			return ConflictError;
+
+		case ErrorType.INVALID:
+			return InvalidError;
+
+		case ErrorType.NOT_ALLOWED:
+			return NotAllowedError;
+
+		case ErrorType.NOT_FOUND:
+			return NotFoundError;
+
+		case ErrorType.NOT_IMPLEMENTED:
+			return NotImplementedError;
+
+		case ErrorType.OMITTED:
+			return OmittedError;
+
+		case ErrorType.TIMEOUT:
+			return TimeoutError;
+
+		case ErrorType.UNAUTHORIZED:
+			return UnauthorizedError;
+
+		default:
+			return GenericError;
+	}
+}
+
+export default createErrorForErrorType;

package/src/lib/errors/utility/create-error-from-ambiguous-json-data.ts

@@ -0,0 +1,26 @@
+import {HttpStatusCode} from 'lib/network';
+
+import BaseError from 'lib/errors/error/base';
+import ErrorType from 'lib/errors/enum/error-type';
+import ErrorData from 'lib/errors/type/error-data';
+import createErrorForErrorType from 'lib/errors/utility/create-error-for-error-type';
+import getErrorTypeForStatusCode from 'lib/errors/utility/get-error-type-for-status-code';
+
+function createErrorFromAmbiguousJsonData(
+	data: object,
+	status_code: HttpStatusCode
+): BaseError {
+	const error_data = data as ErrorData;
+
+	let error_type: ErrorType;
+
+	if (Object.values(ErrorType).includes(error_data.error_type)) {
+		error_type = error_data.error_type;
+	} else {
+		error_type = getErrorTypeForStatusCode(status_code);
+	}
+
+	return createErrorForErrorType(error_type, null, error_data.message);
+}
+
+export default createErrorFromAmbiguousJsonData;

package/src/lib/errors/utility/error-matches.ts

@@ -0,0 +1,28 @@
+import wrapError from 'lib/errors/utility/wrap-error';
+
+interface ErrorConstructor {
+	new (message: string): Error;
+}
+
+function errorMatches(
+	error: unknown,
+	error_constructor: ErrorConstructor
+): boolean {
+	if (!(error instanceof Error)) {
+		return false;
+	}
+
+	if (error.constructor.name === error_constructor.name) {
+		return true;
+	}
+
+	if (error instanceof error_constructor) {
+		return true;
+	}
+
+	const wrapped_error = wrapError(error);
+
+	return wrapped_error.constructor.name === error_constructor.name;
+}
+
+export default errorMatches;

package/src/lib/errors/utility/get-error-type-for-posix-error-code.ts

@@ -0,0 +1,37 @@
+import {PosixErrorCode} from 'lib/process';
+
+import ErrorType from 'lib/errors/enum/error-type';
+
+function getErrorTypeForPosixErrorCode(error_code: PosixErrorCode): ErrorType {
+	switch (error_code) {
+		case PosixErrorCode.EPERM:
+		case PosixErrorCode.EACCES:
+			return ErrorType.UNAUTHORIZED;
+
+		case PosixErrorCode.ENOENT:
+			return ErrorType.NOT_FOUND;
+
+		case PosixErrorCode.EEXIST:
+			return ErrorType.CONFLICT;
+
+		case PosixErrorCode.ENOTDIR:
+		case PosixErrorCode.EISDIR:
+		case PosixErrorCode.EINVAL:
+			return ErrorType.INVALID;
+
+		case PosixErrorCode.EADDRINUSE:
+			return ErrorType.CONFLICT;
+
+		case PosixErrorCode.ETIMEDOUT:
+			return ErrorType.TIMEOUT;
+
+		case PosixErrorCode.ECONNREFUSED:
+		case PosixErrorCode.EHOSTDOWN:
+		case PosixErrorCode.EHOSTUNREACH:
+		// TODO: Add error type for these; they are common enough to warrant it.
+		default:
+			return ErrorType.GENERIC;
+	}
+}
+
+export default getErrorTypeForPosixErrorCode;

package/src/lib/errors/utility/get-error-type-for-status-code.ts

@@ -0,0 +1,38 @@
+import {HttpStatusCode} from 'lib/network';
+
+import ErrorType from 'lib/errors/enum/error-type';
+
+function getErrorTypeForStatusCode(status_code: HttpStatusCode): ErrorType {
+	switch (status_code) {
+		case HttpStatusCode.CONFLICT:
+			return ErrorType.CONFLICT;
+
+		case HttpStatusCode.BAD_REQUEST:
+			return ErrorType.INVALID;
+
+		case HttpStatusCode.FORBIDDEN:
+			return ErrorType.NOT_ALLOWED;
+
+		case HttpStatusCode.FILE_NOT_FOUND:
+			return ErrorType.NOT_FOUND;
+
+		case HttpStatusCode.NOT_IMPLEMENTED:
+			return ErrorType.NOT_IMPLEMENTED;
+
+		case HttpStatusCode.REQUEST_TIMEOUT:
+		case HttpStatusCode.GATEWAY_TIMEOUT:
+			return ErrorType.TIMEOUT;
+
+		case HttpStatusCode.UNAUTHORIZED:
+			return ErrorType.UNAUTHORIZED;
+
+		default:
+			if (status_code >= HttpStatusCode.SERVER_ERROR) {
+				return ErrorType.GENERIC;
+			}
+
+			return ErrorType.INVALID;
+	}
+}
+
+export default getErrorTypeForStatusCode;

package/src/lib/errors/utility/get-message-for-error-type.ts

@@ -0,0 +1,29 @@
+import ErrorType from 'lib/errors/enum/error-type';
+import InvalidError from 'lib/errors/error/invalid';
+
+function getMessageForErrorType(error_type: ErrorType): string {
+	switch (error_type) {
+		case ErrorType.CONFLICT:
+			return 'The desired resource is already claimed.';
+		case ErrorType.GENERIC:
+			return 'Something went wrong.';
+		case ErrorType.INVALID:
+			return 'Invalid request.';
+		case ErrorType.NOT_ALLOWED:
+			return 'Not allowed.';
+		case ErrorType.NOT_FOUND:
+			return 'File not found.';
+		case ErrorType.NOT_IMPLEMENTED:
+			return 'Not yet implemented.';
+		case ErrorType.OMITTED:
+			return 'This value is required.';
+		case ErrorType.TIMEOUT:
+			return 'Request timed out.';
+		case ErrorType.UNAUTHORIZED:
+			return 'Not authorized.';
+		default:
+			throw new InvalidError(`Invalid error type: ${error_type}`);
+	}
+}
+
+export default getMessageForErrorType;

package/src/lib/errors/utility/matches-posix-error-code.ts

@@ -0,0 +1,11 @@
+import {PosixErrorCode} from 'lib/process';
+
+import wrapError from 'lib/errors/utility/wrap-error';
+
+function matchesPosixErrorCode(error: unknown, posix_error_code: PosixErrorCode): boolean {
+	const wrapped_error = wrapError(error);
+
+	return wrapped_error.code === posix_error_code;
+}
+
+export default matchesPosixErrorCode;

package/src/lib/errors/utility/wrap-error.ts

@@ -0,0 +1,39 @@
+import BaseError from 'lib/errors/error/base';
+import GenericError from 'lib/errors/error/generic';
+import createErrorForErrorType from 'lib/errors/utility/create-error-for-error-type';
+import CodedError from 'lib/errors/type/coded-error';
+import getErrorTypeForPosixErrorCode from 'lib/errors/utility/get-error-type-for-posix-error-code';
+
+function wrapError(error: unknown): BaseError {
+	if (error instanceof BaseError) {
+		return error;
+	}
+
+	if (typeof error === 'string') {
+		return new GenericError(error);
+	}
+
+	// Necessary in cases where we're passing around different BaseError
+	// base classes due to library imports.
+	const potential_base_error = error as BaseError;
+
+	if (potential_base_error.getType !== undefined) {
+		return potential_base_error;
+	}
+
+	const coded_error = error as CodedError;
+
+	if (coded_error.code) {
+		const error_type = getErrorTypeForPosixErrorCode(coded_error.code);
+
+		return createErrorForErrorType(
+			error_type,
+			coded_error.code,
+			coded_error.message
+		);
+	}
+
+	return GenericError.fromNativeError(coded_error);
+}
+
+export default wrapError;

package/src/lib/event-emitter/index.ts

@@ -0,0 +1,63 @@
+interface Listener {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	(...args: any[]): void;
+}
+
+interface ListenerMap {
+	[event: string]: Listener[];
+}
+
+abstract class EventEmitter {
+	private listener_map: ListenerMap;
+
+	public constructor() {
+		this.listener_map = {};
+	}
+
+	public on(event: string, listener: Listener): void {
+		const listeners = this.getListenersForEvent(event);
+
+		listeners.push(listener);
+	}
+
+	public removeListener(event: string, listener: Listener): void {
+		const listeners = this.getListenersForEvent(event);
+		const index = listeners.indexOf(listener);
+
+		if (index === -1) {
+			throw new Error(
+				`Could not find listener in list of listeners for event: ${event}`
+			);
+		}
+
+		listeners.splice(index, 1);
+	}
+
+	public removeAllListeners(event: string): void {
+		delete this.listener_map[event];
+	}
+
+	protected emit(event: string, value?: unknown): void {
+		const listeners = this.getListenersForEvent(event);
+
+		listeners.forEach((listener) => {
+			listener(value);
+		});
+	}
+
+	private getListenersForEvent(event: string): Listener[] {
+		const listener_map = this.getListenerMap();
+
+		if (listener_map[event] === undefined) {
+			listener_map[event] = [];
+		}
+
+		return listener_map[event];
+	}
+
+	private getListenerMap(): ListenerMap {
+		return this.listener_map;
+	}
+}
+
+export default EventEmitter;

package/src/lib/execution-context/execution-context.ts

@@ -0,0 +1,90 @@
+import Logger from 'lib/logger';
+import KeyGenerator from 'lib/key-generator';
+
+import Session from 'lib/execution-context/type/session';
+
+import RuntimeConfig from 'type/runtime-config';
+
+class ExecutionContext {
+	private config: RuntimeConfig;
+	private logger: Logger | undefined;
+	private session: Session | undefined;
+	private unique_id: string;
+	private remote_address: string;
+
+	public constructor(config: RuntimeConfig) {
+		this.config = config;
+		this.unique_id = KeyGenerator.generateToken();
+		this.remote_address = '<not set>';
+	}
+
+	public getConfig(): RuntimeConfig {
+		return this.config;
+	}
+
+	public getLogger(): Logger {
+		if (this.logger === undefined) {
+			this.logger = this.createLogger();
+		}
+
+		return this.logger;
+	}
+
+	public getUniqueId(): string {
+		return this.unique_id;
+	}
+
+	public setUniqueId(unique_id: string): this {
+		this.unique_id = unique_id;
+
+		return this;
+	}
+
+	public isLoggedIn(): boolean {
+		const session = this.getSession();
+
+		if (session === undefined) {
+			return false;
+		}
+
+		return session.account_id !== null;
+	}
+
+	public getSessionId(): number | string | undefined {
+		const session = this.getSession();
+
+		if (session === undefined) {
+			return undefined;
+		}
+
+		return session.id;
+	}
+
+	public getSession(): Session | undefined {
+		return this.session;
+	}
+
+	public setSession(session: Session): this {
+		this.session = session;
+		return this;
+	}
+
+	public getRemoteAddress(): string {
+		return this.remote_address;
+	}
+
+	public setRemoteAddress(remote_address: string): void {
+		this.remote_address = remote_address;
+	}
+
+	private createLogger(): Logger {
+		const logger = new Logger();
+		const unique_id = this.getUniqueId();
+
+		logger.setUniqueId(unique_id);
+
+		return logger;
+	}
+}
+
+export default ExecutionContext;

package/src/lib/execution-context/index.ts

@@ -0,0 +1,8 @@
+import ExecutionContext from 'lib/execution-context/execution-context';
+import Session from 'lib/execution-context/type/session';
+
+export {
+	Session
+};
+
+export default ExecutionContext;

package/src/lib/execution-context/type/session.ts

@@ -0,0 +1,7 @@
+type Session = {
+	readonly id: string;
+	readonly account_id: string | null;
+	readonly username: string | null;
+}
+
+export default Session;

package/src/lib/feature/feature.ts

@@ -0,0 +1,108 @@
+import {InvalidError, NotFoundError} from 'lib/errors';
+import {EnvironmentType, getEnvironmentType} from 'lib/environment';
+
+interface FeatureNode {
+	[key: string]: boolean | FeatureNode;
+}
+
+// TODO: Find some way to have this live in a JSON file, while still allowing
+// it to be loaded on the client. Possible solutions include:
+//
+// - finding some damned Webpack adapter or other that allows for importing
+//   JSON files the same way as Common.js modules.
+//
+// - Bypass webpack's punk ass altogether; have some pre-bundler script that
+//   builds the necessary "javascript" file as an artifact and inject it.
+//
+//                                ^
+//                                |
+//                                |
+//                         probably the best approach
+//
+// - importing this data from a separate file on the client (similar to how
+//   Logger is monkey-patched; see web/client/logger). The problem with this
+//   approach is that there are likely still values in the base Feature set
+//   that are still needed (and which would not be specified in the client
+//   feature set). So the question then becomes: do we have some preprocessor
+//   step that finds all the instances of feature checks that are actually
+//   necessary on the client (essentially treating them as dependencies)?
+//   That way we could filter out any feature keys that clients don't need
+//   to know about, and hide details about the internal infrastructure...
+const BASE_DATA: FeatureNode = {
+	metric_tags: false,
+	logger: {
+		json_logging: false
+	}
+};
+
+let EFFECTIVE_DATA = {
+	...BASE_DATA
+};
+
+class Feature {
+	public static setData(data: FeatureNode): void {
+		EFFECTIVE_DATA = {
+			...BASE_DATA,
+			...data
+		};
+	}
+
+	public static resetData(): void {
+		EFFECTIVE_DATA = {
+			...BASE_DATA
+		};
+	}
+
+	public static isEnabled(feature_key: string): boolean {
+		const segments = feature_key.split('.');
+
+		let current_node = EFFECTIVE_DATA;
+
+		while (segments.length > 0) {
+			const current_segment = segments.shift() as string;
+			const next_node = current_node[current_segment];
+
+			if (next_node === undefined) {
+				throw new NotFoundError(`
+					Segment "${current_segment}"
+					from feature key "${feature_key}"
+					did not exist
+				`);
+			}
+
+			if (next_node === true || next_node === false) {
+				return next_node;
+			}
+
+			current_node = next_node;
+		}
+
+		const environment_type = getEnvironmentType();
+		const env_value = current_node[environment_type];
+
+		if (typeof env_value === 'boolean') {
+			return env_value;
+		}
+
+		const all_keys = Object.keys(current_node);
+		const environment_types = Object.values(EnvironmentType) as string[];
+
+		const all_env_keys = all_keys.every((key) => {
+			return environment_types.includes(key);
+		});
+
+		if (all_env_keys) {
+			// If our current environment isn't present in the stanza, but the
+			// stanza otherwise consists of environment type keys, just return
+			// false (ie, assume that whoever omitted this environment type
+			// doesn't want the feature enabled there).
+			return false;
+		}
+
+		throw new InvalidError(`
+			Feature key "${feature_key}" points to a stanza, not a scalar value
+		`);
+	}
+}
+
+export default Feature;

package/src/lib/feature/index.ts

@@ -0,0 +1,3 @@
+import Feature from 'lib/feature/feature';
+
+export default Feature;

package/src/lib/filesystem/bootstrap.ts

@@ -0,0 +1 @@
+throw new Error('Not implemented');

package/src/lib/filesystem/enum/file-extension.ts

@@ -0,0 +1,19 @@
+enum FileExtension {
+	CSS = 'css',
+	GIF = 'gif',
+	HTML = 'html',
+	ICO = 'ico',
+	JPEG = 'jpeg',
+	JPG = 'jpg',
+	JS = 'js',
+	JSON = 'json',
+	MD = 'md',
+	MP3 = 'mp3',
+	PNG = 'png',
+	SQL = 'sql',
+	SWP = 'swp',
+	TXT = 'txt',
+	WAV = 'wav'
+}
+
+export default FileExtension;

package/src/lib/filesystem/index.ts

@@ -0,0 +1,4 @@
+export {default as FileExtension} from 'lib/filesystem/enum/file-extension';
+export {default as getExtensionForFilepath} from 'lib/filesystem/utility/get-extension-for-filepath';
+export {default as stripExtension} from 'lib/filesystem/utility/strip-extension';
+export {default as exists} from 'lib/filesystem/utility/exists';

package/src/lib/filesystem/utility/exists.ts

@@ -0,0 +1,21 @@
+import {access} from 'fs/promises';
+
+import {matchesPosixErrorCode} from 'lib/errors';
+
+import PosixErrorCode from 'lib/process/enum/posix-error-code';
+
+async function exists(filepath: string): Promise<boolean> {
+	try {
+		await access(filepath);
+	} catch (error) {
+		if (matchesPosixErrorCode(error, PosixErrorCode.ENOENT)) {
+			return false;
+		}
+
+		throw error;
+	}
+
+	return true;
+}
+
+export default exists;

package/src/lib/filesystem/utility/get-extension-for-filepath.ts

@@ -0,0 +1,20 @@
+import FileExtension from 'lib/filesystem/enum/file-extension';
+
+function getExtensionForFilepath(filepath: string): FileExtension | undefined {
+	const parts = filepath.split('/');
+	const tail = parts.pop();
+
+	if (tail === undefined || tail.indexOf('.') === -1) {
+		return undefined;
+	}
+
+	const extension = filepath.split('.').pop();
+
+	if (extension === undefined) {
+		return undefined;
+	}
+
+	return extension.toLowerCase() as FileExtension;
+}
+
+export default getExtensionForFilepath;

package/src/lib/filesystem/utility/strip-extension.ts

@@ -0,0 +1,26 @@
+import {InvalidError} from 'lib/errors';
+
+// Basically the opposite of getExtensionForFilepath().
+
+// TODO: Investigate whether it's possible for this to return the full
+// filepath. As it is right now, there are some subtle bugs caused by
+// the fact that it trims off the leading directory as well as the extension.
+function stripExtension(filepath: string): string {
+	const segments = filepath.split('/');
+	const last_segment = segments.pop();
+
+	if (last_segment === undefined) {
+		throw new InvalidError(`Invalid filepath: ${filepath}`);
+	}
+
+	const parts = last_segment.split('.');
+	const prefix = parts[0];
+
+	if (prefix === undefined) {
+		throw new InvalidError(`Invalid filepath segment: ${last_segment}`);
+	}
+
+	return prefix;
+}
+
+export default stripExtension;

package/src/lib/grammar/index.ts

@@ -0,0 +1,3 @@
+export {default as NounInflector} from 'lib/grammar/noun-inflector';
+export {default as VerbInflector} from 'lib/grammar/verb-inflector';
+export {default as getWordsFromIdentifier} from 'lib/grammar/utility/get-words-from-identifier';