fix: 1. JSON Parse received response from socket

2.  Method to close socket connection
3. Connect to socket only when initialize() is called on the module

Author: thebongy

src/main.ts

@@ -1,13 +1,17 @@
 import { Protocol, Dependency, FnArgs } from "./protocol/protocol";
-import { GothamConnection } from './protocol/GothamConnection';
+import { GothamConnection, SocketConnection } from './protocol/GothamConnection';
+import { isMainThread } from 'worker_threads';
 
-export class Gotham {
+export class GothamModule {
     moduleId: string;
     protocol: Protocol
     constructor(connection: GothamConnection) {
         this.protocol = new Protocol(connection);
     }
+
     async initialize(moduleId: string, version: string, deps: Dependency) {
+        // Setup Connection only when initialize called?
+        await this.protocol.connect();
         return await this.protocol.sendRequest(
             this.protocol.initialize(moduleId, version, deps),
         );
@@ -36,4 +40,8 @@ export class Gotham {
             this.protocol.triggerHook(hook)
         );
     }
-}
+
+    async close() {
+        return await this.protocol.close();
+    }
+}

src/protocol/GothamConnection.ts

@@ -1,40 +1,52 @@
-import net from 'net';
+import * as net from 'net';
 
 type dataListenerFn = (data: any) => any;
 export abstract class GothamConnection {
     dataListener: dataListenerFn;
-    constructor() {
-        this.setupConnection();
-    }
 
-   abstract setupConnection();
-   abstract setupDataListener(dataListener: dataListenerFn);
-   abstract async send(message: object): Promise<void>;
+    abstract async setupConnection();
+    abstract async closeConnection();
+    abstract setupDataListener(dataListener: dataListenerFn);
+    abstract async send(message: object): Promise<void>;
 }
 
 
 
 export class SocketConnection extends GothamConnection {
     client: net.Socket;
     sockPath: string;
-    constructor(sockPath: string, dataListener: dataListenerFn) {
+    constructor(sockPath: string) {
         super();
         this.sockPath = sockPath;
     }
 
-    setupConnection() {
-        this.client = net.createConnection(this.sockPath);
-        this.client.on('connect', () => {
-            console.log(`Connected to ${this.sockPath}!`);
+    async setupConnection() {
+        return new Promise((resolve, reject) => {
+            this.client = net.createConnection(this.sockPath);
+            this.client.on('connect', () => {
+                // console.log(`Connected to ${this.sockPath}!`);
+                resolve();
+            });
         });
     }
 
+    async closeConnection() {
+        this.client.destroy();
+    }
+
     setupDataListener(dataListener: dataListenerFn) {
-        this.dataListener = dataListener;
-        this.client.on('data', dataListener);
+        this.dataListener = (data: Buffer) => {
+            const parsed = JSON.parse(data.toString('utf-8'));
+            // console.log("Socket Received Data:");
+            // console.log(parsed);
+            dataListener(parsed);
+        };
+        this.client.on('data', this.dataListener);
     }
 
     async send(message: object) {
+        // console.log("Socker Sending data:");
+        // console.log(message);
         this.client.write(JSON.stringify(message) + '\n');
     }
 }

src/protocol/protocol.ts

@@ -80,19 +80,27 @@ interface DeclareFunctionResponse extends ProtocolMessage {
 
 export class Protocol {
     private moduleId: string;
-    private functions: FnMappings;
-    private hookListeners: HookMappings;
-    private requests: FnMappings;
+    private functions: FnMappings = {};
+    private hookListeners: HookMappings = {};
+    private requests: FnMappings = {};
 
     private connection: GothamConnection;
 
     constructor(connection: GothamConnection) {
         this.connection = connection;
+    }
+
+    async connect() {
+        await this.connection.setupConnection();
         this.connection.setupDataListener((data) => {
             this.parseResponse(data);
         });
     }
 
+    async close() {
+        await this.connection.closeConnection();
+    }
+
     async sendRequest(obj: any) {
         await this.connection.send(obj);
         return new Promise((resolve, reject) => {
@@ -123,9 +131,9 @@ export class Protocol {
 
     registerHook(hook: string, cb: Function): RegisterHookRequest {
         if (this.hookListeners[hook]) {
-            this.hookListeners[hook] = [cb];
-        } else {
             this.hookListeners[hook].push(cb);
+        } else {
+            this.hookListeners[hook] = [cb];
         }
         return {
             requestId: this.generateRequestId(),
@@ -155,7 +163,7 @@ export class Protocol {
         return {
             requestId: this.generateRequestId(),
             type: 'functionCall',
-            function: `${this.moduleId}.${functionName}`,
+            function: `${functionName}`,
             arguments: args
         }
     }
@@ -212,10 +220,17 @@ export class Protocol {
     }
 
     async parseHookTriggered(obj: TriggerHookRequest) {
-        if (this.hookListeners[obj.hook]) {
-            for (const listener of this.hookListeners[obj.hook]) {
-                listener();
+        if (obj.hook) {
+            // Hook triggered by another module.
+            if (this.hookListeners[obj.hook]) {
+                for (const listener of this.hookListeners[obj.hook]) {
+                    listener();
+                }
             }
+            return true;
+        } else {
+            // This moddule triggered the hook. (TODO: Should the callback still be called?)
+            return true;
         }
     }
 }