@fc3/mmcadi 0.1.0 → 0.1.2

package/src/lib/tcp/connection.ts

@@ -1,360 +0,0 @@
-import Logger from 'lib/logger';
-import {Socket, ConnectionStatus} from 'lib/network';
-import EventEmitter from 'lib/event-emitter';
-import KeyGenerator from 'lib/key-generator';
-import {GenericError, ConflictError} from 'lib/errors';
-import {StringEncoding} from 'lib/string';
-import {TimeInterval} from 'lib/time';
-
-import Channel from 'lib/tcp/channel';
-import Message from 'lib/tcp/type/message';
-import MessageType from 'lib/tcp/enum/message-type';
-import ConnectionEvent from 'lib/tcp/enum/connection-event';
-import ChannelOpenMessage from 'lib/tcp/type/message/channel-open';
-import ChannelCloseMessage from 'lib/tcp/type/message/channel-close';
-
-const HEARTBEAT_CHARACTER = '♥';
-const HEARTBEAT_REGEX = new RegExp(HEARTBEAT_CHARACTER, 'g');
-
-class Connection extends EventEmitter {
-	private id: string;
-	private connection_status: ConnectionStatus;
-	private remainder: string;
-	private channels: Channel[];
-	private socket: Socket;
-	private logger: Logger | undefined;
-	private parsing_enabled: boolean;
-
-	public constructor(socket: Socket) {
-		super();
-
-		this.id = KeyGenerator.generateToken();
-
-		if (socket.connecting) {
-			this.connection_status = ConnectionStatus.CONNECTING;
-		} else if (socket.pending === false && socket.readyState === 'open') {
-			this.connection_status = ConnectionStatus.CONNECTED;
-		} else {
-			this.connection_status = ConnectionStatus.DISCONNECTED;
-		}
-
-		this.remainder = '';
-		this.channels = [];
-		this.parsing_enabled = true;
-
-		this.bindHandlers();
-
-		this.socket = socket;
-		this.coupleToSocket(socket);
-	}
-
-	public sendMessage(message: Message): void {
-		const serialized_message = this.serializeMessage(message);
-
-		return this.sendRawMessage(serialized_message);
-	}
-
-	public sendRawMessage(raw_message: string): void {
-		this.validateCanSend();
-
-		const socket = this.getSocket();
-
-		socket.write(raw_message);
-	}
-
-	public end(): void {
-		const socket = this.getSocket();
-
-		socket.end();
-	}
-
-	public getId(): string {
-		return this.id;
-	}
-
-	public disableParsing(): void {
-		this.parsing_enabled = false;
-	}
-
-	public isConnected(): boolean {
-		const connection_status = this.getConnectionStatus();
-
-		return connection_status === ConnectionStatus.CONNECTED;
-	}
-
-	public getChannelById(channel_id: string): Channel {
-		const channels = this.getChannels();
-
-		const channel = channels.find((channel) => {
-			return channel.getId() === channel_id;
-		});
-
-		if (channel === undefined) {
-			throw new Error(`Unable to find channel ${channel_id}`);
-		}
-
-		return channel;
-	}
-
-	public openChannel(channel_id: string): Channel {
-		this.validateChannelId(channel_id);
-
-		const channel = new Channel(channel_id);
-
-		const message = {
-			id: KeyGenerator.generateToken(),
-			message_type: MessageType.CHANNEL_OPEN,
-			channel_id
-		};
-
-		this.sendMessage(message);
-		this.addChannel(channel);
-
-		return channel;
-	}
-
-	public closeChannel(channel_id: string): void {
-		const channel = this.getChannelById(channel_id);
-
-		const message = {
-			id: KeyGenerator.generateToken(),
-			message_type: MessageType.CHANNEL_CLOSE,
-			channel_id
-		};
-
-		this.sendMessage(message);
-		this.removeChannel(channel);
-	}
-
-	public getConnectionStatus(): ConnectionStatus {
-		return this.connection_status;
-	}
-
-	protected setConnectionStatus(connection_status: ConnectionStatus): void {
-		this.connection_status = connection_status;
-		this.emit(ConnectionEvent.STATUS_CHANGE, connection_status);
-	}
-
-	protected getSocket(): Socket {
-		return this.socket;
-	}
-
-	protected coupleToSocket(socket: Socket): void {
-		socket.on('data', this.handleSocketData);
-		socket.on('end', this.handleSocketEnd);
-		socket.on('error', this.handleSocketError);
-	}
-
-	protected bindHandlers(): void {
-		this.handleSocketData = this.handleSocketData.bind(this);
-		this.handleSocketError = this.handleSocketError.bind(this);
-		this.handleSocketEnd = this.handleSocketEnd.bind(this);
-		this.sendHeartbeat = this.sendHeartbeat.bind(this);
-	}
-
-	protected handleSocketError(error: Error): void {
-		this.emit(ConnectionEvent.ERROR, error);
-	}
-
-	protected handleSocketEnd(): void {
-		this.closeChannels();
-
-		this.setConnectionStatus(ConnectionStatus.DISCONNECTED);
-		this.emit(ConnectionEvent.END);
-	}
-
-	protected handleSocketData(data: Buffer): void {
-		const data_string = data
-			.toString(StringEncoding.UTF8)
-			.replace(HEARTBEAT_REGEX, '');
-
-		if (!this.parsingEnabled()) {
-			if (data_string.length > 0) {
-				this.emit(ConnectionEvent.RAW_MESSAGE, data_string);
-			}
-
-			return;
-		}
-
-		const old_remainder = this.getRemainder();
-		const delimiter = this.getMessageDelimiter();
-
-		let combined_string = `${old_remainder}${data_string}`;
-
-		while (combined_string.includes(delimiter)) {
-			const index = combined_string.indexOf(delimiter);
-			const current_segment = combined_string.slice(0, index);
-
-			combined_string = combined_string.slice(index + 1);
-
-			this.parseMessage(current_segment);
-		}
-
-		this.setRemainder(combined_string);
-	}
-
-	protected getLogger(): Logger {
-		if (this.logger === undefined) {
-			this.logger = new Logger();
-		}
-
-		return this.logger;
-	}
-
-	protected sendHeartbeat(): void {
-		if (!this.isConnected()) {
-			return;
-		}
-
-		this.sendRawMessage(HEARTBEAT_CHARACTER);
-
-		const delay = TimeInterval.ONE_SECOND * 5;
-
-		setTimeout(this.sendHeartbeat, delay);
-	}
-
-	private validateCanSend(): void {
-		if (this.isConnected()) {
-			return;
-		}
-
-		const connection_status = this.getConnectionStatus();
-		const id = this.getId();
-
-		const error = new GenericError(`
-			Cannot send message when connection status is ${connection_status}
-			(id: ${id})
-		`);
-
-		throw error;
-	}
-
-	private serializeMessage(message: Message): string {
-		const serialized_message = JSON.stringify(message);
-		const delimiter = this.getMessageDelimiter();
-
-		return `${serialized_message}${delimiter}`;
-	}
-
-	private getMessageDelimiter(): string {
-		return '\n';
-	}
-
-	private parseMessage(raw_message: string): void {
-		if (raw_message.length === 0) {
-			return;
-		}
-
-		let message: Message;
-
-		try {
-			message = JSON.parse(raw_message);
-		} catch (error) {
-			const logger = this.getLogger();
-
-			logger.warn(`Unable to parse socket message: ${raw_message}`);
-
-			this.destroy();
-
-			return;
-		}
-
-		this.emit(ConnectionEvent.MESSAGE, message);
-
-		switch (message.message_type) {
-			case MessageType.CHANNEL_OPEN:
-				return this.handleChannelOpenMessage(message as ChannelOpenMessage);
-			case MessageType.CHANNEL_CLOSE:
-				return this.handleChannelCloseMessage(message as ChannelCloseMessage);
-		}
-	}
-
-	private handleChannelOpenMessage(message: ChannelOpenMessage): void {
-		this.validateChannelId(message.channel_id);
-
-		const channel = new Channel(message.channel_id);
-
-		this.addChannel(channel);
-
-		this.emit(ConnectionEvent.CHANNEL_OPENED, channel);
-	}
-
-	private handleChannelCloseMessage(message: ChannelCloseMessage): void {
-		const channel = this.getChannelById(message.channel_id);
-
-		this.removeChannel(channel);
-
-		this.emit(ConnectionEvent.CHANNEL_CLOSED, channel);
-	}
-
-	private closeChannels(): void {
-		const channels = this.getChannels();
-
-		channels.forEach((channel) => {
-			this.emit(ConnectionEvent.CHANNEL_CLOSED, channel);
-			this.removeChannel(channel);
-		});
-	}
-
-	private addChannel(channel: Channel): void {
-		const channels = this.getChannels();
-
-		channels.push(channel);
-	}
-
-	private removeChannel(channel: Channel): void {
-		const channels = this.getChannels();
-		const index = channels.indexOf(channel);
-
-		if (index === -1) {
-			const channel_id = channel.getId();
-
-			throw new Error(`
-				Tried to remove channel ${channel_id} from channel list,
-				but it was not found
-			`);
-		}
-
-		channels.splice(index, 1);
-	}
-
-	private validateChannelId(channel_id: string): void {
-		if (this.hasChannelId(channel_id)) {
-			throw new ConflictError(`Channel ${channel_id} was already open`);
-		}
-	}
-
-	private hasChannelId(channel_id: string): boolean {
-		const channels = this.getChannels();
-
-		return channels.some((channel) => {
-			return channel.getId() === channel_id;
-		});
-	}
-
-	private getChannels(): Channel[] {
-		return this.channels;
-	}
-
-	private getRemainder(): string {
-		return this.remainder;
-	}
-
-	private setRemainder(remainder: string): void {
-		this.remainder = remainder;
-	}
-
-	private parsingEnabled(): boolean {
-		return this.parsing_enabled;
-	}
-
-	private destroy(): void {
-		if (this.socket === undefined) {
-			return;
-		}
-
-		this.socket.destroy();
-	}
-}
-
-export default Connection;

package/src/lib/tcp/enum/connection-event.ts

@@ -1,12 +0,0 @@
-enum ConnectionEvent {
-	CHANNEL_CLOSED = 'channel_closed',
-	CHANNEL_OPENED = 'channel_opened',
-	CONNECT = 'connect',
-	END = 'end',
-	ERROR = 'error',
-	RAW_MESSAGE = 'raw_message',
-	MESSAGE = 'message',
-	STATUS_CHANGE = 'status_change'
-}
-
-export default ConnectionEvent;

package/src/lib/tcp/enum/message-type.ts

@@ -1,9 +0,0 @@
-enum MessageType {
-	CHANNEL_OPEN = 'channel_open',
-	CHANNEL_CLOSE = 'channel_close',
-	COMMAND = 'command',
-	EVENT = 'event',
-	REQUEST = 'request'
-}
-
-export default MessageType;

package/src/lib/tcp/index.ts

@@ -1 +0,0 @@
-export {default as IncomingConnection} from 'lib/tcp/connection/incoming';

package/src/lib/tcp/type/connection-parameters.ts

@@ -1,6 +0,0 @@
-interface ConnectionParameters {
-	readonly port: number;
-	readonly hostname: string;
-}
-
-export default ConnectionParameters;

package/src/lib/tcp/type/message/channel-close.ts

@@ -1,9 +0,0 @@
-import Message from 'lib/tcp/type/message';
-import MessageType from 'lib/tcp/enum/message-type';
-
-interface ChannelCloseMessage extends Message {
-	readonly message_type: MessageType.CHANNEL_CLOSE;
-	readonly channel_id: string;
-}
-
-export default ChannelCloseMessage;

package/src/lib/tcp/type/message/channel-open.ts

@@ -1,9 +0,0 @@
-import Message from 'lib/tcp/type/message';
-import MessageType from 'lib/tcp/enum/message-type';
-
-interface ChannelOpenMessage extends Message {
-	readonly message_type: MessageType.CHANNEL_OPEN;
-	readonly channel_id: string;
-}
-
-export default ChannelOpenMessage;

package/src/lib/tcp/type/message.ts

@@ -1,10 +0,0 @@
-import MessageType from 'lib/tcp/enum/message-type';
-
-interface Message {
-	readonly message_type: MessageType;
-	readonly id: string;
-	readonly connection_id?: string;
-	readonly channel_id?: string;
-}
-
-export default Message;

package/src/lib/test/index.ts

@@ -1,2 +0,0 @@
-export {default as buildExecutionContext} from 'lib/test/utility/build-execution-context';
-export {default as buildConfig} from 'lib/test/utility/build-config';

package/src/lib/test/utility/build-config.ts

@@ -1,17 +0,0 @@
-import MemoryRepository from 'server/repository/memory';
-import RuntimeConfig from 'type/runtime-config';
-
-function buildConfig(): RuntimeConfig {
-	const public_directory = '/tmp/public';
-	const repository = new MemoryRepository();
-
-	return {
-		public_directory,
-		repository,
-		roles: [],
-		providers: [],
-		hydrate: undefined
-	};
-}
-
-export default buildConfig;

package/src/lib/test/utility/build-execution-context.ts

@@ -1,11 +0,0 @@
-import ExecutionContext from 'lib/execution-context';
-
-import buildConfig from  'lib/test/utility/build-config';
-
-function buildExecutionContext(): ExecutionContext {
-	const config = buildConfig();
-
-	return new ExecutionContext(config);
-}
-
-export default buildExecutionContext;

package/src/lib/time/bootstrap.ts

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

package/src/lib/time/enum/time-interval.ts

@@ -1,12 +0,0 @@
-enum TimeInterval {
-	ONE_FRAME = 16,
-	ONE_SECOND = 1000,
-	ONE_MINUTE = 1000 * 60,
-	ONE_HOUR = 1000 * 60 * 60,
-	ONE_DAY = 1000 * 60 * 60 * 24,
-	ONE_WEEK = 1000 * 60 * 60 * 24 * 7,
-	ONE_MONTH = 1000 * 60 * 60 * 24 * 30,
-	ONE_YEAR = 1000 * 60 * 60 * 24 * 365
-}
-
-export default TimeInterval;

package/src/lib/time/index.ts

@@ -1,4 +0,0 @@
-export {default as TimeInterval} from 'lib/time/enum/time-interval';
-export {default as sleep} from 'lib/time/utility/sleep';
-export {default as formatRelativeDuration} from 'lib/time/utility/format-relative-duration';
-export {default as formatDuration} from 'lib/time/utility/format-duration';

package/src/lib/time/utility/format-duration.ts

@@ -1,139 +0,0 @@
-import {NounInflector} from 'lib/grammar';
-
-import TimeInterval from 'lib/time/enum/time-interval';
-
-function formatMilliseconds(ms: number, shorthand = false): string {
-	if (shorthand) {
-		return `${ms}ms`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(ms, 'millisecond');
-}
-
-function formatSeconds(ms: number, shorthand = false): string {
-	const seconds = Math.floor(ms / TimeInterval.ONE_SECOND);
-
-	if (shorthand) {
-		return `${seconds}s`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(seconds, 'second');
-}
-
-function formatMinutes(ms: number, shorthand = false): string {
-	const minutes = Math.floor(ms / TimeInterval.ONE_MINUTE);
-
-	if (shorthand) {
-		return `${minutes}m`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(minutes, 'minute');
-}
-
-function formatHours(ms: number, shorthand = false): string {
-	const hours = Math.floor(ms / TimeInterval.ONE_HOUR);
-
-	if (shorthand) {
-		return `${hours}h`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(hours, 'hour');
-}
-
-function formatDays(ms: number, shorthand = false): string {
-	const days = Math.floor(ms / TimeInterval.ONE_DAY);
-
-	if (shorthand) {
-		return `${days}d`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(days, 'day');
-}
-
-function formatWeeks(ms: number, shorthand = false): string {
-	const weeks = Math.floor(ms / TimeInterval.ONE_WEEK);
-
-	if (shorthand) {
-		return `${weeks}w`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(weeks, 'week');
-}
-
-function formatMonths(ms: number, shorthand = false): string {
-	const months = Math.floor(ms / TimeInterval.ONE_MONTH);
-
-	if (shorthand) {
-		return `${months}mo`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(months, 'month');
-}
-
-function formatYears(ms: number, shorthand = false): string {
-	let years = ms / TimeInterval.ONE_YEAR;
-
-	const years_rounded = Math.round(years);
-
-	if (Math.abs(years - years_rounded) < 1 / 24) {
-		years = years_rounded;
-	} else {
-		years = parseFloat(years.toFixed(1));
-	}
-
-	if (shorthand) {
-		return `${years}y`;
-	}
-
-	const inflector = new NounInflector();
-
-	return inflector.singularizeOrPluralize(years, 'year');
-}
-
-function formatDuration(ms: number, shorthand = false): string {
-	if (ms < TimeInterval.ONE_SECOND) {
-		return formatMilliseconds(ms, shorthand);
-	}
-
-	if (ms < TimeInterval.ONE_MINUTE) {
-		return formatSeconds(ms, shorthand);
-	}
-
-	if (ms < TimeInterval.ONE_HOUR) {
-		return formatMinutes(ms, shorthand);
-	}
-
-	if (ms < TimeInterval.ONE_DAY) {
-		return formatHours(ms, shorthand);
-	}
-
-	if (ms < TimeInterval.ONE_WEEK) {
-		return formatDays(ms, shorthand);
-	}
-
-	if (ms < TimeInterval.ONE_MONTH) {
-		return formatWeeks(ms, shorthand);
-	}
-
-	if (ms < TimeInterval.ONE_YEAR) {
-		return formatMonths(ms, shorthand);
-	}
-
-	return formatYears(ms, shorthand);
-}
-
-export default formatDuration;

package/src/lib/time/utility/format-relative-duration.ts

@@ -1,22 +0,0 @@
-import formatDuration from 'lib/time/utility/format-duration';
-
-function formatRelativeDuration(
-	date: number | Date | string,
-	shorthand = false
-): string {
-	let ms: number;
-
-	if (date instanceof Date) {
-		ms = date.getTime();
-	} else if (typeof date === 'string') {
-		ms = new Date(date).getTime();
-	} else {
-		ms = date;
-	}
-
-	const elapsed_time = Date.now() - ms;
-
-	return formatDuration(elapsed_time, shorthand);
-}
-
-export default formatRelativeDuration;

package/src/lib/time/utility/sleep.ts

@@ -1,9 +0,0 @@
-function sleep(duration: number): Promise<void> {
-	return new Promise((resolve) => {
-		setTimeout(() => {
-			resolve();
-		}, duration);
-	});
-}
-
-export default sleep;

package/src/operation.ts

@@ -1,18 +0,0 @@
-import {AutoLoggingOperation} from 'lib/operation';
-import ExecutionContext from 'lib/execution-context';
-
-import RuntimeConfig from 'type/runtime-config';
-
-abstract class BaseOperation<T> extends AutoLoggingOperation<T> {
-	public constructor(execution_context: ExecutionContext) {
-		super(execution_context);
-	}
-
-	protected getConfig(): RuntimeConfig {
-		const execution_context = this.getExecutionContext();
-
-		return execution_context.getConfig();
-	}
-}
-
-export default BaseOperation;