feat: Change request/response types to numbers, and support gotham.activated hook

Author: thebongy

src/connection/socket-connection.ts

@@ -14,7 +14,12 @@ export default class SocketConnection extends BaseConnection {
 		return new Promise(resolve => {
 			this.client = net.createConnection(this.sockPath);
 			this.client.on('data', (data) => {
-				this.onData(data);
+				const dataLines = data.toString().split(/\r?\n/);
+				dataLines.map((data) => {
+					if (data) {
+						this.onData(Buffer.from(data))
+					}
+				});
 			});
 			this.client.on('connect', () => {
 				resolve();

src/gotham-node.ts

@@ -13,10 +13,12 @@ import SocketConnection from './connection/socket-connection';
 export default class GothamModule {
 
 	private protocol: BaseProtocol;
+	private moduleId?: string;
 	private connection: BaseConnection;
 	private requests: { [type: string]: Function } = {};
 	private functions: { [type: string]: Function } = {};
 	private hookListeners: { [type: string]: Function[] } = {};
+	private messagBuffer?: Buffer;
 	private registered = false;
 
 	constructor(connection: BaseConnection, protocol: BaseProtocol) {
@@ -34,6 +36,7 @@ export default class GothamModule {
 		version: string,
 		deps: { [type: string]: string } = {}
 	) {
+		this.moduleId = moduleId;
 		// Setup Connection only when initialize called?
 		await this.connection.setupConnection();
 		this.connection.setOnDataListener((data) => {
@@ -85,17 +88,22 @@ export default class GothamModule {
 	}
 
 	private async sendRequest(request: GothamMessage) {
-		if (request.type !== RequestTypes.ModuleRegistration && !this.registered) {
-			throw new Error('Can\'t send request before module has been registered');
-		}
-
-		if (request.type === 'moduleRegistration' && this.registered) {
+		if (request.type === RequestTypes.ModuleRegistration && this.registered) {
 			throw new Error('Module already registered');
 		}
 
-		await this.connection.send(
-			this.protocol.encode(request)
-		);
+		const encoded = this.protocol.encode(request);
+		if (this.registered || request.type === RequestTypes.ModuleRegistration) {
+			await this.connection.send(
+				encoded
+			);
+		} else {
+			if (this.messagBuffer) {
+				this.messagBuffer = Buffer.concat([this.messagBuffer, encoded])
+			} else {
+				this.messagBuffer = encoded;
+			}
+		}
 
 		return new Promise((resolve, reject) => {
 			this.requests[request.requestId] = (response: any) => {
@@ -113,7 +121,6 @@ export default class GothamModule {
 		let value;
 		switch (response.type) {
 			case ResponseTypes.ModuleRegistered: {
-				this.registered = true;
 				value = true;
 				break;
 			}
@@ -159,7 +166,7 @@ export default class GothamModule {
 			}
 			this.sendRequest({
 				requestId: request.requestId,
-				type: 'functionResponse',
+				type: ResponseTypes.FunctionResponse,
 				data: res || {}
 			});
 			return true;
@@ -172,7 +179,12 @@ export default class GothamModule {
 	private async executeHookTriggered(request: TriggerHookRequest) {
 		if (request.hook) {
 			// Hook triggered by another module.
-			if (this.hookListeners[request.hook]) {
+			if (request.hook === `gotham.activated`) {
+				this.registered = true;
+				if (this.messagBuffer) {
+					this.connection.send(this.messagBuffer);
+				}
+			} else if (this.hookListeners[request.hook]) {
 				for (const listener of this.hookListeners[request.hook]) {
 					listener();
 				}

src/models/messages.ts

@@ -1,23 +1,9 @@
-import {
-	ModuleRegistration,
-	DeclareFunction,
-	FunctionCall,
-	RegisterHook,
-	TriggerHook,
-	ModuleRegistered,
-	FunctionResponse,
-	HookRegistered,
-	HookTriggered,
-	FunctionDeclared
-} from '../utils/constants';
-
 interface BaseMessage {
 	requestId: string;
-	type: string;
+	type: number;
 }
 
 export interface RegisterModuleRequest extends BaseMessage {
-	type: ModuleRegistration;
 	moduleId: string;
 	version: string;
 	dependencies: {
@@ -26,50 +12,41 @@ export interface RegisterModuleRequest extends BaseMessage {
 }
 
 export interface DeclareFunctionRequest extends BaseMessage {
-	type: DeclareFunction;
 	function: string;
 }
 
 export interface FunctionCallRequest extends BaseMessage {
-	type: FunctionCall;
 	function: string;
 	arguments: {
 		[type: string]: any
 	};
 }
 
 export interface RegisterHookRequest extends BaseMessage {
-	type: RegisterHook;
 	hook: string;
 }
 
 export interface TriggerHookRequest extends BaseMessage {
-	type: TriggerHook;
 	hook: string;
 }
 
 export interface RegisterModuleResponse extends BaseMessage {
-	type: ModuleRegistered;
 	test: string;
 }
 
 export interface FunctionCallResponse extends BaseMessage {
-	type: FunctionResponse;
 	data: any;
 }
 
 export interface ListenHookResponse extends BaseMessage {
-	type: HookRegistered;
 }
 
 export interface TriggerHookResponse extends BaseMessage {
-	type: HookTriggered;
 	hook: string;
 	data?: any;
 }
 
 export interface DeclareFunctionResponse extends BaseMessage {
-	type: FunctionDeclared;
 	function: string;
 }
 

src/protocol/base-protocol.ts

@@ -1,4 +1,3 @@
-import { RequestTypes } from '../utils/constants';
 import {
 	RegisterHookRequest,
 	TriggerHookRequest,
@@ -7,6 +6,7 @@ import {
 	RegisterModuleRequest,
 	GothamMessage
 } from '../models/messages';
+import { RequestTypes } from '../utils/constants';
 
 export abstract class BaseProtocol {
 	private moduleId = 'undefined';
@@ -27,7 +27,7 @@ export abstract class BaseProtocol {
 		this.moduleId = moduleId;
 		return {
 			requestId: this.generateRequestId(),
-			type: 'moduleRegistration',
+			type: RequestTypes.ModuleRegistration,
 			moduleId: moduleId,
 			version: version,
 			dependencies: deps
@@ -37,23 +37,23 @@ export abstract class BaseProtocol {
 	public registerHook(hook: string): RegisterHookRequest {
 		return {
 			requestId: this.generateRequestId(),
-			type: 'registerHook',
+			type: RequestTypes.RegisterHook,
 			hook
 		};
 	}
 
 	public triggerHook(hook: string): TriggerHookRequest {
 		return {
 			requestId: this.generateRequestId(),
-			type: 'triggerHook',
+			type: RequestTypes.TriggerHook,
 			hook
 		};
 	}
 
 	public declareFunction(functionName: string): DeclareFunctionRequest {
 		return {
 			requestId: this.generateRequestId(),
-			type: 'declareFunction',
+			type: RequestTypes.DeclareFunction,
 			function: functionName
 		};
 	}
@@ -64,7 +64,7 @@ export abstract class BaseProtocol {
 	): FunctionCallRequest {
 		return {
 			requestId: this.generateRequestId(),
-			type: 'functionCall',
+			type: RequestTypes.FunctionCall,
 			function: functionName,
 			arguments: args
 		};

src/utils/constants.ts

@@ -1,27 +1,27 @@
-export type ModuleRegistration = 'moduleRegistration';
-export type FunctionCall = 'functionCall';
-export type RegisterHook = 'registerHook';
-export type TriggerHook = 'triggerHook';
-export type DeclareFunction = 'declareFunction';
+export type ModuleRegistration = 1;
+export type FunctionCall = 3;
+export type RegisterHook = 5;
+export type TriggerHook = 7;
+export type DeclareFunction = 9;
 
-export type ModuleRegistered = 'moduleRegistered';
-export type FunctionResponse = 'functionResponse';
-export type HookRegistered = 'hookRegistered';
-export type HookTriggered = 'hookTriggered';
-export type FunctionDeclared = 'functionDeclared';
+export type ModuleRegistered = 2;
+export type FunctionResponse = 4;
+export type HookRegistered = 6;
+export type HookTriggered = 8;
+export type FunctionDeclared = 10;
 
 export const RequestTypes = {
-	ModuleRegistration: 'moduleRegistration',
-	FunctionCall: 'functionCall',
-	RegisterHook: 'registerHook',
-	TriggerHook: 'triggerHook',
-	DeclareFunction: 'declareFunction'
+	ModuleRegistration: 1,
+	FunctionCall: 3,
+	RegisterHook: 5,
+	TriggerHook: 7,
+	DeclareFunction: 9
 };
 
 export const ResponseTypes = {
-	ModuleRegistered: 'moduleRegistered',
-	FunctionResponse: 'functionResponse',
-	HookRegistered: 'hookRegistered',
-	HookTriggered: 'hookTriggered',
-	FunctionDeclared: 'functionDeclared'
+	ModuleRegistered: 2,
+	FunctionResponse: 4,
+	HookRegistered: 6,
+	HookTriggered: 8,
+	FunctionDeclared: 10
 };

test/gotham-node-test.d.ts

@@ -1,10 +1,10 @@
-import { GothamConnection } from "../src/GothamConnection";
+import BaseConnection from "../src/connection/base-connection";
 import GothamModule from "../src/gotham-node";
 import { SinonSpy } from "sinon";
 import { DummyGothamConnection } from "./helpers";
 
 interface GothamTest {
-	connection: GothamConnection;
+	connection: BaseConnection;
 }
 
 declare module 'mocha' {

test/gotham-node.test.ts

@@ -45,7 +45,7 @@ makeConnectionTests('Initalize Tests', function () {
 			this.test.module.declareFunction('test', () => { })
 		).to.be.rejectedWith(Error);
 		await expect(
-			this.test.module.functionCall('test', {})
+			this.test.module.callFunction('test', {})
 		).to.be.rejectedWith(Error);
 		await expect(
 			this.test.module.registerHook('test', () => { })
@@ -82,7 +82,7 @@ makeConnectionTests('Test if requests constructed correctly', function () {
 
 
 	it('functionCall with empty args', function () {
-		this.test.module.functionCall('module.test_fn');
+		this.test.module.callFunction('module.test_fn');
 		const message = this.test.getLatestSent();
 		expect(message).excluding('requestId').to.deep.equal({
 			function: "module.test_fn",
@@ -92,7 +92,7 @@ makeConnectionTests('Test if requests constructed correctly', function () {
 	});
 
 	it('functionCall with args', function () {
-		this.test.module.functionCall('module.test_fn', {
+		this.test.module.callFunction('module.test_fn', {
 			a: 1,
 			b: 2
 		});
@@ -188,7 +188,7 @@ makeConnectionTests('Test if responses from gotham parsed correctly', async func
 	});
 
 	it('functionResponse', async function() {
-		const p = this.test.module.functionCall('module.test_fn');
+		const p = this.test.module.callFunction('module.test_fn');
 		await sleep(0);
 		const requestId = this.test.getLatestSent().requestId;
 

test/helpers.ts

@@ -1,17 +1,24 @@
-import { GothamConnection } from "../src/GothamConnection";
+import BaseConnection, { OnDataHandler } from "../src/connection/base-connection";
 
-import { dataListenerFn } from "../src/types/protocol";
 
 import sinon from "sinon";
 
 import GothamModule from "../src/gotham-node";
+import { JsonProtocol } from "../src/protocol/json-protocol";
 
 export const sleep = (t: number) => new Promise((r) => setTimeout(r, t));
 
-export class DummyGothamConnection extends GothamConnection {
-	dataListener: dataListenerFn;
-	setupDataListener(fn: dataListenerFn) {
-		this.dataListener = fn;
+export class DummyGothamConnection extends BaseConnection {
+	dataListener: OnDataHandler;
+	async send(request: Buffer) {
+	}
+
+	async setupConnection() {
+
+	}
+
+	async closeConnection() {
+
 	}
 
 	sendResponse(message: any) {
@@ -33,7 +40,8 @@ export function makeConnectionTests(name: string, tests: Function, initalizeModu
 			}
 			sinon.replace(this.currentTest.conn, 'send', this.currentTest.sendFunc);
 			this.currentTest.module = new GothamModule(
-				this.currentTest.conn
+				this.currentTest.conn,
+				new JsonProtocol(),
 			);
 
 			if (initalizeModule) {