updated: newest widely supported javascript spec

Author: RyLee Harrison

.gitignore

@@ -3,6 +3,8 @@ logs
 *.log
 npm-debug.log*
 
+*.lock
+
 # Runtime data
 pids
 *.pid

index.js

@@ -1,89 +1,103 @@
-'use strict';
-var mqtt = require('mqtt');
-var inArray = require('in-array');
-
-var RegularClientPrototype = mqtt.MqttClient.prototype;
-
-var ASYNC_METHODS = ['publish',
-  'subscribe',
-  'unsubscribe',
-  'end'
-];
-
-var SYNC_METHODS = [
-  'addListener',
-  'emit',
-  'eventNames',
-  'getMaxListeners',
-  'listenerCount',
-  'listeners',
-  'off',
-  'on',
-  'once',
-  'prependListener',
-  'prependOnceListener',
-  'removeAllListeners',
-  'removeListener',
-  'setMaxListeners',
-  'rawListeners'
-];
+const mqtt = require('mqtt');
+const RegularClientPrototype = mqtt.MqttClient.prototype;
 
-module.exports = {
-  connect: connect,
-  AsyncClient: AsyncClient
-};
+class AsyncClient {
+  constructor(client) {
+    this.client = client
+  }
 
-function connect (brokerURL, opts) {
-  var client = mqtt.connect(brokerURL, opts);
+  set handleMessage(newHandler) {
+    this.client.handleMessage = newHandler;
+  }
 
-  var asyncClient = new AsyncClient(client);
+  get handleMessage() {
+    return this.client.handleMessage;
+  }
 
-  return asyncClient;
-}
+  publish(...args) {
+    return Promise.resolve(this.client.publish(...args))
+  }
+  
+  subscribe(...args) {
+    return Promise.resolve(this.client.subscribe(...args))
+  }
+  
+  unsubscribe(...args) {
+    return Promise.resolve(this.client.unsubscribe(...args))
+  }
 
-function AsyncClient (client) {
-  this._client = client;
-}
+  end(...args) {
+    return Promise.resolve(this.client.end(...args))
+  }
 
-AsyncClient.prototype = {
-  set handleMessage (newHandler) {
-    this._client.handleMessage = newHandler;
-  },
-  get handleMessage () {
-    return this._client.handleMessage;
+  addListener(...args) {
+    this.client.addListener(...args);
   }
-};
 
-ASYNC_METHODS.forEach(defineAsync);
-SYNC_METHODS.forEach(definePassthrough);
+  emit(...args) {
+    this.client.emit(...args);
+  }
 
-function definePassthrough (name) {
-  AsyncClient.prototype[name] = function () {
-    var client = this._client;
-    return client[name].apply(client, arguments);
-  };
-}
+  eventNames(...args) {
+    this.client.eventNames(...args);
+  }
+
+  getMaxListeners(...args) {
+    this.client.getMaxListeners(...args);
+  }
+
+  listenerCount(...args) {
+    this.client.listenerCount(...args);
+  }
+
+  listeners(...args) {
+    this.client.listeners(...args);
+  }
 
-function defineAsync (name) {
-  AsyncClient.prototype[name] = function asyncMethod () {
-    var client = this._client;
-    var args = [];
-    var length = arguments.length;
-    var i = 0;
-    for (i; i < length; i++)
-      args.push(arguments[i]);
-
-    return new Promise(function (resolve, reject) {
-      args.push(makeCallback(resolve, reject));
-      client[name].apply(client, args);
-    });
-  };
+  off(...args) {
+    this.client.off(...args);
+  }
+
+  on(...args) {
+    this.client.on(...args);
+  }
+
+  once(...args) {
+    this.client.once(...args);
+  }
+
+  prependListener(...args) {
+    this.client.prependListener(...args);
+  }
+
+  prependOnceListener(...args) {
+    this.client.prependOnceListener(...args);
+  }
+
+  removeAllListeners(...args) {
+    this.client.removeAllListeners(...args);
+  }
+
+  removeListener(...args) {
+    this.client.removeListener(...args);
+  }
+
+  setMaxListeners(...args) {
+    this.client.setMaxListeners(...args);
+  }
+
+  rawListeners(...args) {
+    this.client.rawListeners(...args);
+  }
+};
+
+const connect = (brokerUrl, opts = {}) => {
+  const client = mqtt.connect(brokerUrl, opts);
+  const asyncClient = new AsyncClient(client);
+  return asyncClient
 }
 
-function makeCallback (resolve, reject) {
-  return function (err, data) {
-    if (err)
-      reject(err);
-    else resolve(data);
-  };
+module.exports = {
+  connect,
+  AsyncClient
 }

test.js

@@ -1,93 +1,89 @@
-'use strict';
+const Server = require('mqtt/test/server');
 
-var Server = require('mqtt/test/server');
+const AsyncMQTT = require('./');
+const AsyncClient = AsyncMQTT.AsyncClient;
 
-var AsyncMQTT = require('./');
-var AsyncClient = AsyncMQTT.AsyncClient;
+const test = require('tape');
 
-var test = require('tape');
+const SERVER_PORT = 1883;
+const SERVER_URL = `mqtt://localhost:${SERVER_PORT}`;
 
-var SERVER_PORT = 1883;
-var SERVER_URL = 'mqtt://localhost:' + SERVER_PORT;
-
-var server = buildServer().listen(SERVER_PORT);
+const server = buildServer().listen(SERVER_PORT);
 server.unref();
 
 server.on('listening', runTests);
 
 function runTests () {
-  test('Connect should return an instance of AsyncClient', function (t) {
+  test('Connect should return an instance of AsyncClient', t => {
     t.plan(1);
-    var client = AsyncMQTT.connect(SERVER_URL);
+    const client = AsyncMQTT.connect(SERVER_URL);
 
     t.ok(client instanceof AsyncClient, 'Connect returned an AsyncClient');
     client.end();
   });
 
-  test('Should be able to listen on event on client', function (t) {
+  test('Should be able to listen on event on client', t => {
     t.plan(1);
 
-    var client = AsyncMQTT.connect(SERVER_URL);
+    const client = AsyncMQTT.connect(SERVER_URL);
 
-    client.once('connect', function () {
+    client.once('connect', () => {
       t.pass('Connected');
       client.end();
     });
   });
 
-  test('Calling end() should resolve once disconnected', function (t) {
+  test('Calling end() should resolve once disconnected', t => {
     t.plan(2);
 
-    var client = AsyncMQTT.connect(SERVER_URL);
+    const client = AsyncMQTT.connect(SERVER_URL);
 
-    client.on('close', function () {
+    client.on('close', () => {
       t.pass('Close event occured');
     });
 
-    client.on('connect', function () {
+    client.on('connect', () => {
       // Wait for connect to emit before ending
-      client.end().then(function () {
+      client.end().then(() => {
         t.pass('End resolved');
       });
     });
   });
 
-  test('Calling subscribe should resolve once subscribed', function (t) {
+  test('Calling subscribe should resolve once subscribed', t => {
     t.plan(1);
 
-    var client = AsyncMQTT.connect(SERVER_URL);
+    const client = AsyncMQTT.connect(SERVER_URL);
 
     client.subscribe('example', {
       qos: 1
-    }).then(function () {
+    }).then(() => {
       t.pass('Subscribed');
       client.end();
     })
   });
 
-  test('Calling unsubscribe should resolve once completed', function (t) {
+  test('Calling unsubscribe should resolve once completed', t => {
     t.plan(1);
 
-    var client = AsyncMQTT.connect(SERVER_URL);
+    const client = AsyncMQTT.connect(SERVER_URL);
 
     client.subscribe('example', {
       qos: 1
-    }).then(function () {
-      return client.unsubscribe('example');
-    }).then(function () {
+    }).then(() => client.unsubscribe('example')).then(() => {
       t.pass('Unsunbscribed');
       return client.end();
     });
   });
 
-  test('Calling publish should resolve once completed', function (t) {
+  test('Calling publish should resolve once completed', t => {
     t.plan(1);
 
-    var client = AsyncMQTT.connect(SERVER_URL);
+    const client = AsyncMQTT.connect(SERVER_URL);
 
     client.publish('example', 'test', {
       qos: 1
-    }).then(function () {
+    }).then(() => {
       t.pass('Published');
       return client.end();
     });
@@ -96,17 +92,17 @@ function runTests () {
 
 // Taken from MQTT.js tests
 function buildServer () {
-  return new Server(function (client) {
-    client.on('connect', function (packet) {
-      if ('invalid' === packet.clientId) {
+  return new Server(client => {
+    client.on('connect', ({clientId}) => {
+      if ('invalid' === clientId) {
         client.connack({returnCode: 2})
       } else {
         client.connack({returnCode: 0})
       }
     })
 
-    client.on('publish', function (packet) {
-      setImmediate(function () {
+    client.on('publish', packet => {
+      setImmediate(() => {
         switch (packet.qos) {
           case 0:
             break
@@ -122,33 +118,31 @@ function buildServer () {
       })
     })
 
-    client.on('pubrel', function (packet) {
+    client.on('pubrel', packet => {
       client.pubcomp(packet)
     })
 
-    client.on('pubrec', function (packet) {
+    client.on('pubrec', packet => {
       client.pubrel(packet)
     })
 
-    client.on('pubcomp', function () {
+    client.on('pubcomp', () => {
       // Nothing to be done
     })
 
-    client.on('subscribe', function (packet) {
+    client.on('subscribe', ({messageId, subscriptions}) => {
       client.suback({
-        messageId: packet.messageId,
-        granted: packet.subscriptions.map(function (e) {
-          return e.qos
-        })
+        messageId: messageId,
+        granted: subscriptions.map(({qos}) => qos)
       })
     })
 
-    client.on('unsubscribe', function (packet) {
+    client.on('unsubscribe', packet => {
       client.unsuback(packet)
     })
 
-    client.on('pingreq', function () {
+    client.on('pingreq', () => {
       client.pingresp()
     })
-  })
+  });
 }