@fc3/mmcadi 0.1.0 → 0.1.1

package/src/lib/process/execute.ts

@@ -1,77 +0,0 @@
-import ChildProcess from 'child_process';
-
-import Logger from 'lib/logger';
-import ProcessError from 'lib/process/error';
-import PromiseWrapper from 'lib/promise-wrapper';
-import CommandOptions from 'lib/process/type/command-options';
-
-let LOGGER: Logger | undefined;
-
-function getLogger(): Logger {
-	if (LOGGER === undefined) {
-		LOGGER = new Logger();
-	}
-
-	return LOGGER;
-}
-
-function execute(command: string, options?: CommandOptions): Promise<string> {
-	const promise_wrapper = new PromiseWrapper<string>();
-
-	options = {
-		...options
-	};
-
-	const cwd = options.cwd || process.cwd();
-	const logger = getLogger();
-
-	if (!options.silent) {
-		logger.info(`${cwd} > ${command}`);
-	}
-
-	function reject(error: string | Error): void {
-		// TODO: Interestingly, the error being passed in is not necessarily an
-		// instance of the base Error class... are there separate base error
-		// classes in play here? That sounds dangerous (given that we do
-		// instanceof Error checks in various places...). Needs investigation.
-		if (typeof error === 'string') {
-			error = new ProcessError(error);
-		}
-
-		promise_wrapper.reject(error);
-	}
-
-	// TODO: Figure out what is the appropriate thing to do with stderr...
-	// Maybe for now just throw an exception if it is present?
-	ChildProcess.exec(
-		command,
-		options,
-		(error: Error | null, stdout: string, stderr: string) => {
-			if (error === null) {
-				promise_wrapper.resolve(stdout);
-				return;
-			}
-
-			// Sometimes the process will emit output on stdout, and then return
-			// a non-zero exit code (eg, `service status xxx` when the service isn't
-			// currently running). When that happens, return an error with stdout:
-			if (!stderr && stdout) {
-				return reject(stdout);
-			}
-
-			if (error.message.includes('Command failed:') === false) {
-				return reject(error);
-			}
-
-			if (stderr) {
-				return reject(stderr);
-			}
-
-			return reject(error);
-		}
-	);
-
-	return promise_wrapper.getPromise();
-}
-
-export default execute;

package/src/lib/process/index.ts

@@ -1,4 +0,0 @@
-export {default as ProcessSignal} from 'lib/process/enum/process-signal';
-export {default as PosixErrorCode} from 'lib/process/enum/posix-error-code';
-export {default as bindProcessLifespanTo} from 'lib/process/utility/bind-process-lifespan-to';
-export {default as execute} from 'lib/process/execute';

package/src/lib/process/type/command-options.ts

@@ -1,9 +0,0 @@
-interface CommandOptions {
-	readonly cwd?: string;
-	readonly uid?: number;
-	readonly gid?: number;
-	readonly stream?: boolean;
-	readonly silent?: boolean;
-}
-
-export default CommandOptions;

package/src/lib/process/utility/bind-process-lifespan-to.ts

@@ -1,10 +0,0 @@
-import Logger from 'lib/logger';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function bindProcessLifespanTo(promise: Promise<any>): void {
-	const logger = new Logger();
-
-	promise.then(logger.successAndExit).catch(logger.errorAndExit);
-}
-
-export default bindProcessLifespanTo;

package/src/lib/promise-wrapper/index.ts

@@ -1,3 +0,0 @@
-import PromiseWrapper from 'lib/promise-wrapper/promise-wrapper';
-
-export default PromiseWrapper;

package/src/lib/promise-wrapper/promise-wrapper.ts

@@ -1,51 +0,0 @@
-interface Callback<T> {
-	(error: Error | undefined | null, result: T): void;
-}
-
-class PromiseWrapper<T> {
-	// TODO: Remove this and just use sleep()
-	public static resolveAfterDelay(delay: number): Promise<void> {
-		const promise_wrapper = new PromiseWrapper<void>();
-
-		setTimeout(() => {
-			promise_wrapper.resolve();
-		}, delay);
-
-		return promise_wrapper.getPromise();
-	}
-
-	private promise: Promise<T>;
-	private resolver!: (result: T) => void;
-	private rejector!: (error: Error) => void;
-
-	public constructor() {
-		this.promise = new Promise<T>((resolver, rejector) => {
-			this.resolver = resolver;
-			this.rejector = rejector;
-		});
-	}
-
-	public getPromise(): Promise<T> {
-		return this.promise;
-	}
-
-	public getCallback(): Callback<T> {
-		return (error: Error | undefined | null, result: T) => {
-			if (error) {
-				this.reject(error);
-			} else {
-				this.resolve(result);
-			}
-		};
-	}
-
-	public resolve(result?: T): void {
-		this.resolver(result as T);
-	}
-
-	public reject(error: Error): void {
-		this.rejector(error);
-	}
-}
-
-export default PromiseWrapper;

package/src/lib/random/chance.ts

@@ -1,5 +0,0 @@
-function randomChance(percentage: number): boolean {
-	return Math.random() <= percentage;
-}
-
-export default randomChance;

package/src/lib/random/element.ts

@@ -1,7 +0,0 @@
-function randomElement<T>(elements: T[]): T | undefined {
-	const index = Math.floor(Math.random() * elements.length);
-
-	return elements[index];
-}
-
-export default randomElement;

package/src/lib/random/elements.ts

@@ -1,12 +0,0 @@
-import {clone} from 'lib/array';
-
-function randomElements<T>(elements: T[]): T[] {
-	const count = Math.floor(Math.random() * elements.length);
-	const randomized_elements = clone(elements).sort(() => {
-		return Math.random() - 0.5;
-	});
-
-	return randomized_elements.slice(0, count);
-}
-
-export default randomElements;

package/src/lib/random/enum.ts

@@ -1,34 +0,0 @@
-import randomElement from 'lib/random/element';
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-function randomEnum<T>(enum_values: object): T {
-	interface IndexableEnum {
-		[key: string]: T;
-	}
-
-	const keys = Object.keys(enum_values);
-	const key = randomElement(keys) as string;
-	const numeric_key = (key as unknown) as number;
-
-	// The way that Typescript transpiles enums with numeric-values into objects
-	// is dangerous. It creates reverse mappings between the values and the keys,
-	// whereas with a string-value enum, it does not. This is unintuitive and a
-	// potential footgun, so I'm opting to just raise a hard exception here.
-	if (isNaN(numeric_key) === false) {
-		throw new Error('Do not use randomEnum() on numeric-value enums');
-	}
-
-	const coerced_values = enum_values as IndexableEnum;
-	const value = coerced_values[key];
-	const numeric_value = (value as unknown) as number;
-
-	// Same note as above; here we're accounting for the opposite "lucky" case,
-	// where a string key was selected that points to a numeric value.
-	if (isNaN(numeric_value) === false) {
-		throw new Error('Do not use randomEnum() on numeric-value enums');
-	}
-
-	return value;
-}
-
-export default randomEnum;

package/src/lib/random/enums.ts

@@ -1,11 +0,0 @@
-import randomElements from 'lib/random/elements';
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-function randomEnum<T>(enum_values: object): T[] {
-	const values = Object.values(enum_values);
-	const random_values = randomElements(values);
-
-	return random_values as T[];
-}
-
-export default randomEnum;

package/src/lib/random/index.ts

@@ -1,3 +0,0 @@
-export {default as randomEnum} from 'lib/random/enum';
-export {default as randomElement} from 'lib/random/element';
-export {default as randomNumber} from 'lib/random/number';

package/src/lib/random/number.ts

@@ -1,8 +0,0 @@
-function randomNumber(min: number, max: number): number {
-	const delta = max - min;
-	const value = Math.round(Math.random() * delta);
-
-	return Math.round(min + value);
-}
-
-export default randomNumber;

package/src/lib/server/base.ts

@@ -1,194 +0,0 @@
-import Net from 'net';
-import Util from 'util';
-import {EventEmitter} from 'events';
-
-import RuntimeConfig from 'type/runtime-config';
-
-import Logger from 'lib/logger';
-
-import {GenericError} from 'lib/errors';
-import {NetworkProtocol} from 'lib/network';
-
-import ServerStatus from 'lib/server/enum/server-status';
-import ServerOptions from 'lib/server/type/server-options';
-
-abstract class Server extends EventEmitter {
-	private raw_server: Net.Server;
-	private options: ServerOptions;
-	private status: ServerStatus;
-	private logger: Logger | undefined;
-
-	public constructor(options: ServerOptions, raw_server: Net.Server) {
-		super();
-
-		this.raw_server = raw_server;
-		this.status = ServerStatus.NOT_STARTED;
-		this.options = options;
-
-		this.bindHandlersInternal();
-	}
-
-	public async start(): Promise<void> {
-		this.validateCanStart();
-		this.setStatus(ServerStatus.STARTING);
-
-		const raw_server = this.getRawServer();
-		const logger = this.getLogger();
-		const port = this.getPort();
-		const protocol = this.getProtocol();
-		const label = this.getLabel();
-
-		raw_server.listen(port);
-		logger.info(`${label} ${protocol} server listening on port ${port}`);
-	}
-
-	public async stop(): Promise<void> {
-		const logger = this.getLogger();
-		const label = this.getLabel();
-		const protocol = this.getProtocol();
-
-		if (this.isNotStarted() || this.isStopped()) {
-			return void logger.warn(`
-				${label} ${protocol} server was not running; skipping shutdown...
-			`);
-		}
-
-		logger.info(`Stopping ${label} ${protocol} server...`);
-
-		this.validateCanStop();
-		this.setStatus(ServerStatus.STOPPING);
-
-		const raw_server = this.getRawServer();
-		const close = Util.promisify(raw_server.close.bind(raw_server));
-		const promise = close();
-
-		await promise;
-
-		logger.info(`${label} ${protocol} server was stopped`);
-	}
-
-	public setLogger(logger: Logger): void {
-		this.logger = logger;
-	}
-
-	public canStart(): boolean {
-		const status = this.getStatus();
-
-		return status === ServerStatus.NOT_STARTED;
-	}
-
-	public canStop(): boolean {
-		const status = this.getStatus();
-
-		switch (status) {
-			case ServerStatus.STARTING:
-			case ServerStatus.LISTENING:
-				return true;
-			default:
-				return false;
-		}
-	}
-
-	protected getConfig(): RuntimeConfig {
-		const {config} = this.getServerOptions();
-
-		return config;
-	}
-
-	protected getPort(): number {
-		const {port} = this.getServerOptions();
-
-		return port;
-	}
-
-	protected getLabel(): string {
-		const {label} = this.getServerOptions();
-
-		return label;
-	}
-
-	protected getLogger(): Logger {
-		if (this.logger === undefined) {
-			this.logger = new Logger();
-		}
-
-		return this.logger;
-	}
-
-	protected getRawServer(): Net.Server {
-		return this.raw_server;
-	}
-
-	protected getServerOptions(): ServerOptions {
-		return this.options;
-	}
-
-	private bindHandlersInternal(): void {
-		const raw_server = this.getRawServer();
-
-		raw_server.on('listening', this.handleListening.bind(this));
-		raw_server.on('error', this.handleError.bind(this));
-		raw_server.on('close', this.handleClosed.bind(this));
-
-		this.bindHandlers();
-	}
-
-	private handleListening(): void {
-		this.setStatus(ServerStatus.LISTENING);
-	}
-
-	private handleError(error: Error): void {
-		const logger = this.getLogger();
-
-		logger.error(error);
-	}
-
-	private handleClosed(): void {
-		this.setStatus(ServerStatus.STOPPED);
-	}
-
-	private validateCanStart(): void {
-		if (this.canStart()) {
-			return;
-		}
-
-		const status = this.getStatus();
-
-		throw new GenericError(`Unable to start server in ${status} status`);
-	}
-
-	private validateCanStop(): void {
-		if (this.canStop()) {
-			return;
-		}
-
-		const status = this.getStatus();
-
-		throw new GenericError(`Unable to stop server in ${status} status`);
-	}
-
-	private isNotStarted(): boolean {
-		const status = this.getStatus();
-
-		return status === ServerStatus.NOT_STARTED;
-	}
-
-	private isStopped(): boolean {
-		const status = this.getStatus();
-
-		return status === ServerStatus.STOPPED;
-	}
-
-	private getStatus(): ServerStatus {
-		return this.status;
-	}
-
-	private setStatus(status: ServerStatus): void {
-		this.status = status;
-	}
-
-	protected abstract bindHandlers(): void;
-	protected abstract getProtocol(): NetworkProtocol;
-}
-
-export default Server;

package/src/lib/server/enum/server-event.ts

@@ -1,5 +0,0 @@
-enum ServerEvent {
-	CONNECTION = 'connection'
-}
-
-export default ServerEvent;

package/src/lib/server/enum/server-status.ts

@@ -1,10 +0,0 @@
-enum ServerStatus {
-	NOT_STARTED = 'not_started',
-	STARTING = 'starting',
-	LISTENING = 'listening',
-	STOPPING = 'stopping',
-	STOPPED = 'stopped',
-	CRASHED = 'crashed'
-}
-
-export default ServerStatus;

package/src/lib/server/http/endpoint/ping.ts

@@ -1,21 +0,0 @@
-import {HttpMethod, ContentType} from 'lib/http';
-
-import Endpoint from 'lib/server/http/endpoint';
-
-interface PingResult {
-	status: string;
-}
-
-class PingEndpoint extends Endpoint<unknown, PingResult> {
-	public path = '/ping';
-	public method = HttpMethod.GET;
-	public content_types = [ContentType.JSON];
-
-	protected process(): Promise<PingResult> {
-		return Promise.resolve({
-			status: 'OK'
-		});
-	}
-}
-
-export default PingEndpoint;