aconnector - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

index.js

@@ -5,14 +5,15 @@ const net = require("net");
 module.exports.ConnectorClient = class ConnectorClient extends EventEmitter {
+
     constructor(key) {
         super();
         this._socket = new net.Socket()
-                .on('connect', () => {
-                    this._socket.write(key);
-                })
-                .on('error', err => {
-                    this.emit("error", err);
-                })
-                .on('close', () => {
-                    this.emit("disconnect");
-                });
+            .on('connect', () => {
+                this._socket.write(key);
+            })
+            .on('error', err => {
+                this.emit("error", err);
+            })
+            .on('close', () => {
+                this.emit("disconnect");
+            });
         this._authorized = false;
@@ -23,20 +24,32 @@ this._requests = {};
 
-    connect(port, address) {
+    async connect(port, address) {
         this._socket.connect(port, address);
-
         this._socket.removeAllListeners("data");
-        this._socket.on('data', data => {
-            if (data != "SUCCESS_AUTH")
-                return;
-            this.emit("connect");
-            this._socket.removeAllListeners("data");
-            this._socket.on("data", (data) => {
+        await new Promise((resolve, reject) => {
+            this._socket.on('data', data => {
                 data = JSON.parse(data);
-                if ("request" in data) {
-                    let request = data.request;
-                    delete data.request;
-                    return this._response(request, data);
-                } else if ("event" in data) {
-                    return this.emit(data.event, data.data);
+                if (data.code != "SUCCESS_AUTH")
+                    return;
+                for (let meth of data.methods) {
+                    Object.defineProperty(this, meth, {
+                        value: async (...args) => {
+                            return await this._request(meth, ...args);
+                        }
+                    });
                 }
+                this.emit("connect");
+                this._socket.removeAllListeners("data");
+                this._socket.on("data", (data) => {
+                    data = JSON.parse(data);
+                    if ("request" in data) {
+                        let request = data.request;
+                        delete data.request;
+                        if (request in this._requests && typeof this._requests[request] == "function")
+                            return this._requests[request](data);
+                        console.log("Got unhandled response from request ", request);
+                    } else if ("event" in data) {
+                        return this.emit(data.event, data.data);
+                    }
+                });
+                resolve(true);
             });
@@ -47,8 +60,3 @@ });
 
-    async _response(request, data) {
-        if (request in this._requests && typeof this._requests[request] == "function")
-            this._requests[request](data);
-    }
-
-    async request(command, data, success, error) {
+    async _request(command, data, success = false, error = false, timeout = false) {
         let _ID = +new Date;
@@ -61,73 +69,89 @@ this._socket.write(JSON.stringify({
         return await new Promise((resolve, reject) => {
-            this._requests[_ID] = (data) => {
-                try {
-                    if (data.success) {
-                        if (typeof success == "function")
-                            return resolve(success(data.data));
-                        return resolve(data.data);
+                this._requests[_ID] = (data) => {
+                    try {
+                        if (data.success) {
+                            if (typeof success == "function")
+                                return resolve(success(data.data));
+                            return resolve(data.data);
+                        }
+                        let e = data.error;
+                        if (typeof error == "object") {
+                            if (typeof error[e.code] == "function")
+                                return resolve(error[e.code](e.data, e));
+                            i   f (typeof error["default"] == "function")
+                                return resolve(error["default"](e.code, e.data, e));
+                        } else if (typeof error == "function") {
+                            return resolve(error(e.code, e.data, e));
+                        }
+                        return reject(e);
                     }
-                    let e = data.error;
-                    if (typeof error == "object") {
-                        if (typeof error[e.code] == "function")
-                            return resolve(error[e.code](e.data, e));
-                        if (typeof error["default"] == "function")
-                            return resolve(error["default"](e.code, e.data, e));
-                    } else if (typeof error == "function") {
-                        return resolve(error(e.code, e.data, e));
+                    catch
+                        (e) {
+                        return reject(e);
                     }
-                    return reject(e);
-                } catch (e) {
-                    return reject(e);
-                }
-            };
-            setTimeout(() => {
-                //reject([]);
-            }, 5000);
-        });
+                };
+                setTimeout(() => {
+                    reject("__TIMEOUT__");
+                }, timeout | 5000);
+            }
+        )
+            ;
     }
-};
+}
+;
 
 module.exports.ConnectorServer = class ConnectorServer extends EventEmitter {
-    constructor(key) {
+    constructor(key, handler) {
         super();
-        this._sockets = {};
-        this._commands = {};
-        this._server = net.createServer(socket => {
-            let sockID = +new Date;
-            this._sockets[sockID] = socket;
-            socket.send = (event, data) => {
-                console.log(event, data);
-                socket.write(JSON.stringify({event, data}));
-            };
+        Object.defineProperty(this, "_sockets", {value: {}});
+        Object.defineProperty(this, "_handler", {value: handler});
+        Object.defineProperty(this, "_server", {
+            value: net.createServer(socket => {
+                let sockID = +new Date;
+                this._sockets[sockID] = socket;
+                socket.send = (event, data) => {
+                    console.log(event, data);
+                    socket.write(JSON.stringify({event, data}));
+                };
 
-            socket.on("data", data => {
-                if (data != key)
-                    return socket.write("__NEED_CODE__");
+                socket.on("data", data => {
+                    if (data != key)
+                        return socket.write(JSON.stringify({code: "__WRONG_PASSCODE__"}));
 
-                socket.write("SUCCESS_AUTH");
-                socket.removeAllListeners("data");
+                    socket.write(JSON.stringify({
+                        code: "SUCCESS_AUTH",
+                        methods: Object.keys(this._handler)
+                    }));
+                    socket.removeAllListeners("data");
 
-                socket.on("data", data => {
-                    data = JSON.parse(data);
-                    this._handleRequest(data, socket).then(result => {
-                        socket.write(JSON.stringify({
-                            success: true,
-                            data: result,
-                            request: data._ID
-                        }));
-                    }).catch(e => {
-                        if (typeof e == "string") {
-                            e = {code: e};
-                        } else if (Array.isArray(e)) {
-                            e = {code: e[0], data: e[1]};
+                    socket.on("data", async data => {
+                        try {
+                            data = JSON.parse(data);
+                            let result = await this._handleRequest(data, socket);
+                            socket.write(JSON.stringify({
+                                success: true,
+                                data: result,
+                                request: data._ID
+                            }));
+                        } catch (e) {
+                            switch (typeof e) {
+                                case "string":
+                                    e = {code: e};
+                                    break;
+                                case "object":
+                                    if (Array.isArray(e)) {
+                                        e = {code: e[0], data: e[1]};
+                                    } else if (e instanceof Error) {
+                                        e = {code: "__INTERNAL_SERVER_ERROR__", data: e};
+                                    }
+                            }
+                            socket.write(JSON.stringify({
+                                success: false,
+                                error: e,
+                                request: data._ID
+                            }));
                         }
-                        console.warn({"someError": e});
-                        socket.write(JSON.stringify({
-                            success: false,
-                            error: e,
-                            request: data._ID
-                        }));
                     });
                 });
-            });
+            })
         });
@@ -144,13 +168,8 @@ }
     async _handleRequest(params, socket) {
-        if (params.command in this._commands)
-            return await this._commands[params.command](params.data, socket);
-        this.REQUIRES(false, "__INVALID_COMMAND__");
+        if (params.command in this._handler)
+            return await this._handler[params.command](params.data, socket);
+        this.REQUIRE(false, "__INVALID_COMMAND__");
     }
 
-    register(command, handler) {
-        this._commands[command] = handler;
-        return this;
-    }
-
-    REQUIRES(condition, error) {
+    REQUIRE(condition, error) {
         if (!condition)
@@ -157,0 +176,0 @@ throw error;

package.json

 {
   "name": "aconnector",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "mocha *.test.js"
   },
@@ -18,3 +18,6 @@ "repository": {
   },
-  "homepage": "https://github.com/ArStah/node-connector#readme"
+  "homepage": "https://github.com/ArStah/node-connector#readme",
+  "devDependencies": {
+    "mocha": "^4.0.1"
+  }
 }

Fixed alerts

No tests

Quality

Package does not have any tests. This is a strong signal of a poorly maintained or low quality package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

12057

increased by80.55%

Number of package files

8

increased by166.67%

Lines of code

222

increased by57.45%

Number of low quality alerts

1

decreased by-50%

Worsened metrics

Dev dependency count

1

increased byInfinity%

No dependency changes