feat: Implement socket connection logic

Author: thebongy

src/main.ts

@@ -1,10 +1,11 @@
 import { Protocol, Dependency, FnArgs } from "./protocol/protocol";
+import { GothamConnection } from './protocol/GothamConnection';
 
 export class Gotham {
     moduleId: string;
     protocol: Protocol
-    constructor() {
-        this.protocol = new Protocol();
+    constructor(connection: GothamConnection) {
+        this.protocol = new Protocol(connection);
     }
     async initialize(moduleId: string, version: string, deps: Dependency) {
         return await this.protocol.sendRequest(

src/protocol/GothamConnection.ts

@@ -1,13 +1,40 @@
-class GothamConnection {
+import net from 'net';
+
+type dataListenerFn = (data: any) => any;
+export abstract class GothamConnection {
+    dataListener: dataListenerFn;
     constructor() {
-        // Connect to socket
+        this.setupConnection();
+    }
+
+   abstract setupConnection();
+   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) {
+        super();
+        this.sockPath = sockPath;
+    }
+
+    setupConnection() {
+        this.client = net.createConnection(this.sockPath);
+        this.client.on('connect', () => {
+            console.log(`Connected to ${this.sockPath}!`);
+        });
     }
 
-    async send(_message: object) {
-        // Send message over socket 
+    setupDataListener(dataListener: dataListenerFn) {
+        this.dataListener = dataListener;
+        this.client.on('data', dataListener);
     }
 
-    async receive() {
-        // Receive a message from the socket
+    async send(message: object) {
+        this.client.write(JSON.stringify(message) + '\n');
     }
-}
+}

src/protocol/protocol.ts

@@ -1,6 +1,5 @@
 import { constants } from "../constants";
-import { ConnectOpts } from 'net';
-import { ConnectionOptions } from 'tls';
+import { GothamConnection } from './GothamConnection';
 
 export interface Dependency {
     [type: string]: string;
@@ -87,6 +86,13 @@ export class Protocol {
 
     private connection: GothamConnection;
 
+    constructor(connection: GothamConnection) {
+        this.connection = connection;
+        this.connection.setupDataListener((data) => {
+            this.parseResponse(data);
+        });
+    }
+
     async sendRequest(obj: any) {
         await this.connection.send(obj);
         return new Promise((resolve, reject) => {
@@ -184,7 +190,7 @@ export class Protocol {
             res = false;
         }
 
-        // Call the callback proviced while sending the request
+        // Call the callback provided while sending the request
         if (this.requests[obj.requestId]) {
             this.requests[obj.requestId](res);
             delete this.requests[obj.requestId];

tsconfig.json

@@ -12,8 +12,6 @@
     "forceConsistentCasingInFileNames": true,
     "noFallthroughCasesInSwitch": true,
     "noImplicitReturns": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
     "noImplicitAny": false,
     "noImplicitThis": false,
     "strictNullChecks": false