@fc3/mmcadi 0.1.0 → 0.1.2

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/lib/feature/feature.ts

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

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

package/src/lib/filesystem/bootstrap.ts

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

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

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

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

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

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

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

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