pusher 4.0.2 → 5.1.0-beta

package/.github/stale.yml

@@ -1,7 +1,7 @@
 # Configuration for probot-stale - https://github.com/probot/stale
 
 # Number of days of inactivity before an Issue or Pull Request becomes stale
-daysUntilStale: 365
+daysUntilStale: 90
 
 # Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
 # Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
@@ -23,4 +23,4 @@ markComment: >
   This issue has been automatically marked as stale because it has not had
   recent activity. It will be closed if no further activity occurs. If you'd
   like this issue to stay open please leave a comment indicating how this issue
-  is affecting you. Thankyou.
+  is affecting you. Thank you.

package/.github/workflows/test.yml

@@ -0,0 +1,36 @@
+name: Tests
+
+on:
+  pull_request:
+  push:
+    branches: [master, main]
+
+jobs:
+  test:
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        node: [10.x, 10.x, 12.x, 14.x]
+
+    name: Node.js ${{ matrix.node }} Test
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run linter
+        run: npm run lint
+
+      - name: Run test suite
+        run: npm test
+        env:
+          PUSHER_URL: ${{ secrets.INTEGRATION_TESTS_PUSHER_URL }}

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 5.1.0-beta (2022-04-22)
+
+[ADDED] Support for terminating user connections based on user id
+[ADDED] Support for sending messages to users based on user id
+[ADDED] Support for implementing user authentication endpoints
+[DEPRECATED] authenticate function is deprecated. The same functionality (and interface) is now provided by authorizeChannel
+
+## 5.0.1 (2022-01-24)
+
+[FIXED] Incorrect `require` on `version.js` was causing a compilation error in Webpack
+[FIXED] Inconsistent encoding for shared secret between other SDKs
+
+## 5.0.0 (2021-02-18)
+
+[BREAKING CHANGE] `trigger` now accepts a `params` _object_ instead of a `socket_id` as the third parameter.
+
+[ADDED] Support for requesting channel attributes as part of a `trigger` and `triggerBatch` request via an `info` parameter.
+
 ## 4.0.2 (2020-11-30)
 
 [FIXED] Workaround for a [Webpack bug](https://github.com/webpack/webpack/issues/4742) (thanks @JJ-Kidd)
@@ -46,6 +64,7 @@ const pusher = new Pusher.forURL(process.env.PUSHER_URL, {
 [UPGRADED] development dependencies
 
 [ADDED] encryptionMasterKeyBase64 constructor parameter to make it easier to use the full range of 32 byte binary values in encryption key
+
 [DEPRECATED] encryptionMasterKey constructor parameter - use encryptionMasterKeyBase64
 
 ## 3.0.0 (2019-09-26)

package/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/pusher/pusher-http-node.svg?branch=master)](https://travis-ci.org/pusher/pusher-http-node)
+[![Build Status](https://github.com/pusher/pusher-http-node/workflows/Tests/badge.svg)](https://github.com/pusher/pusher-http-node/actions?query=workflow%3ATests+branch%3Amaster)
 [![npm version](https://badge.fury.io/js/pusher.svg)](https://badge.fury.io/js/pusher)
 
 # Pusher Channels Node.js REST library
@@ -7,15 +7,15 @@ In order to use this library, you need to have an account on <https://pusher.com
 
 ## Supported platforms
 
-This SDK supports **Node.js** version 8+.
+This SDK supports **Node.js** version 10+.
 
-We test the library against a selection of Node.js versions which we update over time. Please refer to [travis.yml](https://github.com/pusher/pusher-http-node/blob/master/.travis.yml) for the set of versions that are currently tested with CI.
+We test the library against a selection of Node.js versions which we update over time. Please refer to [test.yml](https://github.com/pusher/pusher-http-node/blob/master/.github/workflows/test.yml) for the set of versions that are currently tested with CI.
 
 If you find any compatibility issues, please [raise an issue](https://github.com/pusher/pusher-http-node/issues/new) in the repository or contact support at [support@pusher.com](support@pusher.com). We will happily investigate reported problems ❤️.
 
 ## Installation
 
-You need to be running at least Node.js 8 to use this library.
+You need to be running at least Node.js 10 to use this library.
 
 ```
 $ npm install pusher
@@ -160,18 +160,88 @@ You can trigger a batch of up to 10 events.
 
 ### Excluding event recipients
 
-In order to avoid the client that triggered the event from also receiving it, the `trigger` function takes an optional `socketId` parameter. For more informaiton see: <http://pusher.com/docs/publisher_api_guide/publisher_excluding_recipients>.
+In order to avoid the client that triggered the event from also receiving it, a `socket_id` parameter can be added to the `params` object. For more information see: <http://pusher.com/docs/publisher_api_guide/publisher_excluding_recipients>.
 
 ```javascript
-const socketId = "1302.1081607"
-pusher.trigger(channel, event, data, socketId)
+pusher.trigger(channel, event, data, { socket_id: "1302.1081607" })
+
+pusher.triggerBatch([
+  { channel: channel, name: name, data: data, socket_id: "1302.1081607" },
+])
+```
+
+### Fetch subscriber and user counts at the time of publish [[EXPERIMENTAL](https://pusher.com/docs/lab#experimental-program)]
+
+For the channels that were published to, you can request for the number of subscribers or user to be returned in the response body.
+
+#### Regular triggering
+
+```javascript
+pusher
+  .trigger("presence-my-channel", "event", "test", { info: "user_count,subscription_count" })
+  .then(response => {
+    if (response.status !== 200) {
+      throw Error("unexpected status")
+    }
+    // Parse the response body as JSON
+    return response.json()
+  )
+  .then(body => {
+    const channelsInfo = body.channels
+    // Do something with channelsInfo
+  })
+  .catch(error => {
+    // Handle error
+  })
+```
+
+#### Batch triggering
+
+```javascript
+const batch = [
+  {
+    channel: "my-channel",
+    name: "event",
+    data: "test1",
+    info: "subscription_count",
+  },
+  {
+    channel: "presence-my-channel",
+    name: "event",
+    data: "test2",
+    info: "user_count,subscription_count",
+  },
+]
+pusher
+  .triggerBatch(batch)
+  .then((response) => {
+    if (response.status !== 200) {
+      throw Error("unexpected status")
+    }
+    // Parse the response body as JSON
+    return response.json()
+  })
+  .then((body) => {
+    body.batch.forEach((attributes, i) => {
+      process.stdout.write(
+        `channel: ${batch[i].channel}, name: ${batch[i].name}, subscription_count: ${attributes.subscription_count}`
+      )
+      if ("user_count" in attributes) {
+        process.stdout.write(`, user_count: ${attributes.user_count}`)
+      }
+      process.stdout.write("\n")
+    })
+  })
+  .catch((error) => {
+    console.error(error)
+  })
 ```
 
-### End-to-end encryption [BETA]
+### End-to-end encryption
 
 This library supports end-to-end encryption of your private channels. This means that only you and your connected clients will be able to read your messages. Pusher cannot decrypt them. You can enable this feature by following these steps:
 
-1. You should first set up Private channels. This involves [creating an authentication endpoint on your server](https://pusher.com/docs/authenticating_users).
+1. You should first set up Private channels. This involves [creating an authorization endpoint on your server](https://pusher.com/docs/authenticating_users).
 
 2. Next, generate your 32 byte master encryption key, encode it as base64 and pass it to the Pusher constructor.
 
@@ -208,17 +278,44 @@ pusher.trigger(["channel-1", "private-encrypted-channel-2"], "test_event", {
 
 Rationale: the methods in this library map directly to individual Channels HTTP API requests. If we allowed triggering a single event on multiple channels (some encrypted, some unencrypted), then it would require two API requests: one where the event is encrypted to the encrypted channels, and one where the event is unencrypted for unencrypted channels.
 
-### Authenticating private channels
+### Authenticating users
+
+To authenticate users during sign in, you can use the `authenticateUser` function:
+
+```javascript
+const userData = {
+  id: "unique_user_id",
+  name: "John Doe",
+  image: "https://...",
+}
+const auth = pusher.authenticateUser(socketId, userData)
+```
+
+The `userData` parameter must contain an `id` property with a non empty string. For more information see: <http://pusher.com/docs/authenticating_users>
+
+### Terminating user connections
+
+In order to terminate a user's connections, the user must have been authenticated. Check the [Server user authentication docs](http://pusher.com/docs/authenticating_users) for the information on how to create a user authentication endpoint.
+
+To terminate all connections established by a given user, you can use the `terminateUserConnections` function:
+
+```javascript
+pusher.terminateUserConnections(userId)
+```
+
+Please note, that it only terminates the user's active connections. This means, if nothing else is done, the user will be able to reconnect. For more information see: [Terminating user connections docs](https://pusher.com/docs/channels/server_api/terminating-user-connections/).
+
+### Private channel authorisation
 
-To authorise your users to access private channels on Pusher Channels, you can use the `authenticate` function:
+To authorise your users to access private channels on Pusher Channels, you can use the `authorizeChannel` function:
 
 ```javascript
-const auth = pusher.authenticate(socketId, channel)
+const auth = pusher.authorizeChannel(socketId, channel)
 ```
 
 For more information see: <http://pusher.com/docs/authenticating_users>
 
-### Authenticating presence channels
+### Presence channel authorisation
 
 Using presence channels is similar to private channels, but you can specify extra data to identify that particular user:
 
@@ -230,7 +327,7 @@ const channelData = {
     twitter_id: '@leggetter'
   }
 };
-const auth = pusher.authenticate(socketId, channel, channelData);
+const auth = pusher.authorizeChannel(socketId, channel, channelData);
 ```
 
 The `auth` is then returned to the caller as JSON.

package/examples/typescript/main.ts

@@ -4,8 +4,7 @@ import * as Pusher from "pusher"
 
 const pusher = Pusher.forURL(process.env.PUSHER_URL, {
   encryptionMasterKeyBase64: Buffer.from(
-    "01234567890123456789012345678901",
-    "binary"
+    "01234567890123456789012345678901"
   ).toString("base64"),
   agent: new Agent({ keepAlive: true }),
 })

package/index.d.ts

@@ -10,7 +10,7 @@ declare class Pusher {
     channel: string | Array<string>,
     event: string,
     data: any,
-    socketId?: string
+    params?: Pusher.TriggerParams
   ): Promise<Response>
 
   trigger(
@@ -61,10 +61,17 @@ declare namespace Pusher {
 
   export type Options = ClusterOptions | HostOptions
 
+  export interface TriggerParams {
+    socket_id?: string
+    info?: string
+  }
+
   export interface BatchEvent {
     channel: string
     name: string
     data: any
+    socket_id?: string
+    info?: string
   }
 
   type ReservedParams =

package/lib/auth.js

@@ -1,5 +1,14 @@
 const util = require("./util")
 
+function getSocketSignatureForUser(token, socketId, userData) {
+  const serializedUserData = JSON.stringify(userData)
+  const signature = token.sign(`${socketId}::user::${serializedUserData}`)
+  return {
+    auth: `${token.key}:${signature}`,
+    user_data: serializedUserData,
+  }
+}
+
 function getSocketSignature(pusher, token, channel, socketID, data) {
   const result = {}
 
@@ -26,4 +35,5 @@ function getSocketSignature(pusher, token, channel, socketID, data) {
   return result
 }
 
+exports.getSocketSignatureForUser = getSocketSignatureForUser
 exports.getSocketSignature = getSocketSignature

package/lib/config.js

@@ -49,7 +49,7 @@ function Config(options) {
       )
     }
 
-    this.encryptionMasterKey = options.encryptionMasterKey
+    this.encryptionMasterKey = Buffer.from(options.encryptionMasterKey)
   }
 
   // Handle base64 encoded 32 byte key to encourage use of the full range of byte values
@@ -61,10 +61,7 @@ function Config(options) {
       throw new Error("encryptionMasterKeyBase64 must be valid base64")
     }
 
-    const decodedKey = Buffer.from(
-      options.encryptionMasterKeyBase64,
-      "base64"
-    ).toString("binary")
+    const decodedKey = Buffer.from(options.encryptionMasterKeyBase64, "base64")
     if (decodedKey.length !== 32) {
       throw new Error(
         "encryptionMasterKeyBase64 must decode to 32 bytes, but the string " +

package/lib/events.js

@@ -23,16 +23,14 @@ function encrypt(pusher, channel, data) {
   })
 }
 
-exports.trigger = function (pusher, channels, eventName, data, socketId) {
+exports.trigger = function (pusher, channels, eventName, data, params) {
   if (channels.length === 1 && util.isEncryptedChannel(channels[0])) {
     const channel = channels[0]
     const event = {
       name: eventName,
       data: encrypt(pusher, channel, data),
       channels: [channel],
-    }
-    if (socketId) {
-      event.socket_id = socketId
+      ...params,
     }
     return pusher.post({ path: "/events", body: event })
   } else {
@@ -49,9 +47,7 @@ exports.trigger = function (pusher, channels, eventName, data, socketId) {
       name: eventName,
       data: ensureJSON(data),
       channels: channels,
-    }
-    if (socketId) {
-      event.socket_id = socketId
+      ...params,
     }
     return pusher.post({ path: "/events", body: event })
   }

package/lib/pusher.js

@@ -34,6 +34,19 @@ const validateSocketId = function (socketId) {
   }
 }
 
+const validateUserId = function (userId) {
+  if (typeof userId !== "string" || userId === "") {
+    throw new Error("Invalid user id: '" + userId + "'")
+  }
+}
+
+const validateUserData = function (userData) {
+  if (userData == null || typeof userData !== "object") {
+    throw new Error("Invalid user data: '" + userData + "'")
+  }
+  validateUserId(userData.id)
+}
+
 /** Provides access to Pusher's REST API, WebHooks and authentication.
  *
  * @constructor
@@ -103,9 +116,9 @@ Pusher.forCluster = function (cluster, options) {
  * @param {String} socketId socket id
  * @param {String} channel channel name
  * @param {Object} [data] additional socket data
- * @returns {String} authentication signature
+ * @returns {String} authorization signature
  */
-Pusher.prototype.authenticate = function (socketId, channel, data) {
+Pusher.prototype.authorizeChannel = function (socketId, channel, data) {
   validateSocketId(socketId)
   validateChannel(channel)
 
@@ -118,6 +131,60 @@ Pusher.prototype.authenticate = function (socketId, channel, data) {
   )
 }
 
+/** Returns a signature for given socket id, channel and socket data.
+ *
+ *  DEPRECATED. Use authorizeChannel.
+ *
+ * @param {String} socketId socket id
+ * @param {String} channel channel name
+ * @param {Object} [data] additional socket data
+ * @returns {String} authorization signature
+ */
+Pusher.prototype.authenticate = Pusher.prototype.authorizeChannel
+
+/** Returns a signature for given socket id and user data.
+ *
+ * @param {String} socketId socket id
+ * @param {Object} userData user data
+ * @returns {String} authentication signature
+ */
+Pusher.prototype.authenticateUser = function (socketId, userData) {
+  validateSocketId(socketId)
+  validateUserData(userData)
+
+  return auth.getSocketSignatureForUser(this.config.token, socketId, userData)
+}
+
+/** Sends an event to a user.
+ *
+ * Event name can be at most 200 characters long.
+ *
+ * @param {String} userId user id
+ * @param {String} event event name
+ * @param data event data, objects are JSON-encoded
+ * @returns {Promise} a promise resolving to a response, or rejecting to a RequestError.
+ * @see RequestError
+ */
+Pusher.prototype.sendToUser = function (userId, event, data) {
+  if (event.length > 200) {
+    throw new Error("Too long event name: '" + event + "'")
+  }
+  validateUserId(userId)
+  return events.trigger(this, [`#server-to-user-${userId}`], event, data)
+}
+
+/** Terminate users's connections.
+ *
+ *
+ * @param {String} userId user id
+ * @returns {Promise} a promise resolving to a response, or rejecting to a RequestError.
+ * @see RequestError
+ */
+Pusher.prototype.terminateUserConnections = function (userId) {
+  validateUserId(userId)
+  return this.post({ path: `/users/${userId}/terminate_connections`, body: {} })
+}
+
 /** Triggers an event.
  *
  * Channel names can contain only characters which are alphanumeric, '_' or '-'
@@ -130,12 +197,14 @@ Pusher.prototype.authenticate = function (socketId, channel, data) {
  * @param {String|String[]} channel list of at most 100 channels
  * @param {String} event event name
  * @param data event data, objects are JSON-encoded
- * @param {String} [socketId] id of a socket that should not receive the event
+ * @param {Object} [params] additional optional request body parameters
+ * @param {String} [params.socket_id] id of a socket that should not receive the event
+ * @param {String} [params.info] a comma separate list of attributes to be returned in the response. Experimental, see https://pusher.com/docs/lab#experimental-program
  * @see RequestError
  */
-Pusher.prototype.trigger = function (channels, event, data, socketId) {
-  if (socketId) {
-    validateSocketId(socketId)
+Pusher.prototype.trigger = function (channels, event, data, params) {
+  if (params && params.socket_id) {
+    validateSocketId(params.socket_id)
   }
   if (!(channels instanceof Array)) {
     // add single channel to array for multi trigger compatibility
@@ -150,7 +219,7 @@ Pusher.prototype.trigger = function (channels, event, data, socketId) {
   for (let i = 0; i < channels.length; i++) {
     validateChannel(channels[i])
   }
-  return events.trigger(this, channels, event, data, socketId)
+  return events.trigger(this, channels, event, data, params)
 }
 
 /* Triggers a batch of events
@@ -159,7 +228,9 @@ Pusher.prototype.trigger = function (channels, event, data, socketId) {
  * {
  *   name: string,
  *   channel: string,
- *   data: any JSON-encodable data
+ *   data: any JSON-encodable data,
+ *   socket_id: [optional] string,
+ *   info: [optional] string experimental, see https://pusher.com/docs/lab#experimental-program
  * }
  */
 Pusher.prototype.triggerBatch = function (batch) {
@@ -230,7 +301,9 @@ Pusher.prototype.createSignedQueryString = function (options) {
 Pusher.prototype.channelSharedSecret = function (channel) {
   return crypto
     .createHash("sha256")
-    .update(channel + this.config.encryptionMasterKey)
+    .update(
+      Buffer.concat([Buffer.from(channel), this.config.encryptionMasterKey])
+    )
     .digest()
 }
 

package/lib/version.js

@@ -1 +1 @@
-module.exports = require("../package").version
+module.exports = require("../package.json").version

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pusher",
   "description": "Node.js client to interact with the Pusher Channels REST API",
-  "version": "4.0.2",
+  "version": "5.1.0-beta",
   "author": "Pusher <support@pusher.com>",
   "contributors": [
     {

package/tests/integration/pusher/authenticate.js

@@ -9,38 +9,163 @@ describe("Pusher", function () {
     pusher = new Pusher({ appId: 10000, key: "aaaa", secret: "tofu" })
   })
 
-  describe("#auth", function () {
+  describe("#authenticateUser", function () {
     it("should prefix the signature with the app key", function () {
       let pusher = new Pusher({ appId: 10000, key: "1234", secret: "tofu" })
-      expect(pusher.authenticate("123.456", "test")).to.eql({
+      expect(pusher.authenticateUser("123.456", { id: "45678" })).to.eql({
+        auth:
+          "1234:f4b1fdeea7c93e32648c7230e32b172057c5623cace6cfce791c6e7035e0babd",
+        user_data: '{"id":"45678"}',
+      })
+
+      pusher = new Pusher({ appId: 10000, key: "abcdef", secret: "tofu" })
+      expect(pusher.authenticateUser("123.456", { id: "45678" })).to.eql({
+        auth:
+          "abcdef:f4b1fdeea7c93e32648c7230e32b172057c5623cace6cfce791c6e7035e0babd",
+        user_data: '{"id":"45678"}',
+      })
+    })
+
+    it("should return correct authentication signatures for different user data", function () {
+      expect(pusher.authenticateUser("123.456", { id: "45678" })).to.eql({
+        auth:
+          "aaaa:f4b1fdeea7c93e32648c7230e32b172057c5623cace6cfce791c6e7035e0babd",
+        user_data: '{"id":"45678"}',
+      })
+      expect(
+        pusher.authenticateUser("123.456", { id: "55555", user_name: "test" })
+      ).to.eql({
+        auth:
+          "aaaa:b8a9f173455903792ae2b788add0c4c78ad7372b3ae7fb5769479276a1993743",
+        user_data: JSON.stringify({ id: "55555", user_name: "test" }),
+      })
+    })
+
+    it("should return correct authentication signatures for different secrets", function () {
+      let pusher = new Pusher({ appId: 10000, key: "11111", secret: "1" })
+      expect(pusher.authenticateUser("123.456", { id: "45678" })).to.eql({
+        auth:
+          "11111:79bddf29fe8e2153dd5d8d569b3f45e5aeb26ae2eb4758879d844791b466cfa2",
+        user_data: '{"id":"45678"}',
+      })
+      pusher = new Pusher({ appId: 10000, key: "11111", secret: "2" })
+      expect(pusher.authenticateUser("123.456", { id: "45678" })).to.eql({
+        auth:
+          "11111:a542498ffa6faf6de7c17a8106b923c042319bd73acfd1d274df32e269b55d1f",
+        user_data: '{"id":"45678"}',
+      })
+    })
+
+    it("should return correct authentication signature with utf-8 in user data", function () {
+      expect(pusher.authenticateUser("1.1", { id: "ą§¶™€łü€ß£" })).to.eql({
+        auth:
+          "aaaa:620494cee53d6c568b49598313194088afda37218f0d059af03c0c898ed61ff4",
+        user_data: '{"id":"ą§¶™€łü€ß£"}',
+      })
+    })
+
+    it("should raise an exception if socket id is not a string", function () {
+      expect(function () {
+        pusher.authenticateUser(undefined, { id: "123" })
+      }).to.throwException(/^Invalid socket id: 'undefined'$/)
+      expect(function () {
+        pusher.authenticateUser(null, { id: "123" })
+      }).to.throwException(/^Invalid socket id: 'null'$/)
+      expect(function () {
+        pusher.authenticateUser(111, { id: "123" })
+      }).to.throwException(/^Invalid socket id: '111'$/)
+    })
+
+    it("should raise an exception if socket id is an empty string", function () {
+      expect(function () {
+        pusher.authenticateUser("", { id: "123" })
+      }).to.throwException(/^Invalid socket id: ''$/)
+    })
+
+    it("should raise an exception if socket id is invalid", function () {
+      expect(function () {
+        pusher.authenticateUser("1.1:", { id: "123" })
+      }).to.throwException(/^Invalid socket id/)
+      expect(function () {
+        pusher.authenticateUser(":1.1", { id: "123" })
+      }).to.throwException(/^Invalid socket id/)
+      expect(function () {
+        pusher.authenticateUser(":\n1.1", { id: "123" })
+      }).to.throwException(/^Invalid socket id/)
+      expect(function () {
+        pusher.authenticateUser("1.1\n:", { id: "123" })
+      }).to.throwException(/^Invalid socket id/)
+    })
+
+    it("should raise an exception if user data is not a non-null object", function () {
+      expect(function () {
+        pusher.authenticateUser("111.222", undefined)
+      }).to.throwException(/^Invalid user data: 'undefined'$/)
+      expect(function () {
+        pusher.authenticateUser("111.222", null)
+      }).to.throwException(/^Invalid user data: 'null'$/)
+      expect(function () {
+        pusher.authenticateUser("111.222", 111)
+      }).to.throwException(/^Invalid user data: '111'$/)
+      expect(function () {
+        pusher.authenticateUser("111.222", "")
+      }).to.throwException(/^Invalid user data: ''$/)
+      expect(function () {
+        pusher.authenticateUser("111.222", "abc")
+      }).to.throwException(/^Invalid user data: 'abc'$/)
+    })
+
+    it("should raise an exception if user data doesn't have a valid id field", function () {
+      expect(function () {
+        pusher.authenticateUser("111.222", {})
+      }).to.throwException(/^Invalid user id: 'undefined'$/)
+      expect(function () {
+        pusher.authenticateUser("111.222", { id: "" })
+      }).to.throwException(/^Invalid user id: ''$/)
+      expect(function () {
+        pusher.authenticateUser("111.222", { id: 123 })
+      }).to.throwException(/^Invalid user id: '123'$/)
+    })
+  })
+
+  describe("#authenticate", function () {
+    it("should be the exactly the same as authorizeChannel", function () {
+      expect(pusher.authenticate).to.eql(pusher.authorizeChannel)
+    })
+  })
+
+  describe("#authorizeChannel", function () {
+    it("should prefix the signature with the app key", function () {
+      let pusher = new Pusher({ appId: 10000, key: "1234", secret: "tofu" })
+      expect(pusher.authorizeChannel("123.456", "test")).to.eql({
         auth:
           "1234:efa6cf7644a0b35cba36aa0f776f3cbf7bb60e95ea2696bde1dbe8403b61bd7c",
       })
 
       pusher = new Pusher({ appId: 10000, key: "abcdef", secret: "tofu" })
-      expect(pusher.authenticate("123.456", "test")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "test")).to.eql({
         auth:
           "abcdef:efa6cf7644a0b35cba36aa0f776f3cbf7bb60e95ea2696bde1dbe8403b61bd7c",
       })
     })
 
     it("should return correct authentication signatures for different socket ids", function () {
-      expect(pusher.authenticate("123.456", "test")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "test")).to.eql({
         auth:
           "aaaa:efa6cf7644a0b35cba36aa0f776f3cbf7bb60e95ea2696bde1dbe8403b61bd7c",
       })
-      expect(pusher.authenticate("321.654", "test")).to.eql({
+      expect(pusher.authorizeChannel("321.654", "test")).to.eql({
         auth:
           "aaaa:f6ecb0a17d3e4f68aca28f1673197a7608587c09deb0208faa4b5519aee0a777",
       })
     })
 
     it("should return correct authentication signatures for different channels", function () {
-      expect(pusher.authenticate("123.456", "test1")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "test1")).to.eql({
         auth:
           "aaaa:d5ab857f805433cb50562da96afa41688d7742a3c3a021ed15a4d991a4d8cf94",
       })
-      expect(pusher.authenticate("123.456", "test2")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "test2")).to.eql({
         auth:
           "aaaa:43affa6a09af1fb9ce1cadf176171346beaf7366673ec1e5920f68b3e97a466d",
       })
@@ -48,12 +173,12 @@ describe("Pusher", function () {
 
     it("should return correct authentication signatures for different secrets", function () {
       let pusher = new Pusher({ appId: 10000, key: "11111", secret: "1" })
-      expect(pusher.authenticate("123.456", "test")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "test")).to.eql({
         auth:
           "11111:584828bd6e80b2d177d2b28fde07b8e170abf87ccb5a791a50c933711fb8eb28",
       })
       pusher = new Pusher({ appId: 10000, key: "11111", secret: "2" })
-      expect(pusher.authenticate("123.456", "test")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "test")).to.eql({
         auth:
           "11111:269bbf3f7625db4e0d0525b617efa5915c3ae667fd222dc8e4cb94bc531f26f2",
       })
@@ -61,24 +186,26 @@ describe("Pusher", function () {
 
     it("should return the channel data", function () {
       expect(
-        pusher.authenticate("123.456", "test", { foo: "bar" }).channel_data
+        pusher.authorizeChannel("123.456", "test", { foo: "bar" }).channel_data
       ).to.eql('{"foo":"bar"}')
     })
 
     it("should return correct authentication signatures with and without the channel data", function () {
-      expect(pusher.authenticate("123.456", "test")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "test")).to.eql({
         auth:
           "aaaa:efa6cf7644a0b35cba36aa0f776f3cbf7bb60e95ea2696bde1dbe8403b61bd7c",
       })
-      expect(pusher.authenticate("123.456", "test", { foo: "bar" })).to.eql({
-        auth:
-          "aaaa:f41faf9ead2ea76772cc6b1168363057459f02499ae4d92e88229dc7f4efa2d4",
-        channel_data: '{"foo":"bar"}',
-      })
+      expect(pusher.authorizeChannel("123.456", "test", { foo: "bar" })).to.eql(
+        {
+          auth:
+            "aaaa:f41faf9ead2ea76772cc6b1168363057459f02499ae4d92e88229dc7f4efa2d4",
+          channel_data: '{"foo":"bar"}',
+        }
+      )
     })
 
     it("should return correct authentication signature with utf-8 in channel data", function () {
-      expect(pusher.authenticate("1.1", "test", "ą§¶™€łü€ß£")).to.eql({
+      expect(pusher.authorizeChannel("1.1", "test", "ą§¶™€łü€ß£")).to.eql({
         auth:
           "aaaa:2a229263e89d9c50524fd80c2e88be2843379f6931e28995e2cc214282c9db0c",
         channel_data: '"ą§¶™€łü€ß£"',
@@ -87,58 +214,58 @@ describe("Pusher", function () {
 
     it("should raise an exception if socket id is not a string", function () {
       expect(function () {
-        pusher.authenticate(undefined, "test")
+        pusher.authorizeChannel(undefined, "test")
       }).to.throwException(/^Invalid socket id: 'undefined'$/)
       expect(function () {
-        pusher.authenticate(null, "test")
+        pusher.authorizeChannel(null, "test")
       }).to.throwException(/^Invalid socket id: 'null'$/)
       expect(function () {
-        pusher.authenticate(111, "test")
+        pusher.authorizeChannel(111, "test")
       }).to.throwException(/^Invalid socket id: '111'$/)
     })
 
     it("should raise an exception if socket id is an empty string", function () {
       expect(function () {
-        pusher.authenticate("", "test")
+        pusher.authorizeChannel("", "test")
       }).to.throwException(/^Invalid socket id: ''$/)
     })
 
     it("should raise an exception if socket id is invalid", function () {
       expect(function () {
-        pusher.authenticate("1.1:", "test")
+        pusher.authorizeChannel("1.1:", "test")
       }).to.throwException(/^Invalid socket id/)
       expect(function () {
-        pusher.authenticate(":1.1", "test")
+        pusher.authorizeChannel(":1.1", "test")
       }).to.throwException(/^Invalid socket id/)
       expect(function () {
-        pusher.authenticate(":\n1.1", "test")
+        pusher.authorizeChannel(":\n1.1", "test")
       }).to.throwException(/^Invalid socket id/)
       expect(function () {
-        pusher.authenticate("1.1\n:", "test")
+        pusher.authorizeChannel("1.1\n:", "test")
       }).to.throwException(/^Invalid socket id/)
     })
 
     it("should raise an exception if channel name is not a string", function () {
       expect(function () {
-        pusher.authenticate("111.222", undefined)
+        pusher.authorizeChannel("111.222", undefined)
       }).to.throwException(/^Invalid channel name: 'undefined'$/)
       expect(function () {
-        pusher.authenticate("111.222", null)
+        pusher.authorizeChannel("111.222", null)
       }).to.throwException(/^Invalid channel name: 'null'$/)
       expect(function () {
-        pusher.authenticate("111.222", 111)
+        pusher.authorizeChannel("111.222", 111)
       }).to.throwException(/^Invalid channel name: '111'$/)
     })
 
     it("should raise an exception if channel name is an empty string", function () {
       expect(function () {
-        pusher.authenticate("111.222", "")
+        pusher.authorizeChannel("111.222", "")
       }).to.throwException(/^Invalid channel name: ''$/)
     })
 
     it("should throw an error for private-encrypted- channels", function () {
       expect(function () {
-        pusher.authenticate("123.456", "private-encrypted-bla", "foo")
+        pusher.authorizeChannel("123.456", "private-encrypted-bla", "foo")
       }).to.throwException(
         "Cannot generate shared_secret because encryptionMasterKey is not set"
       )
@@ -149,30 +276,30 @@ describe("Pusher", function () {
 describe("Pusher with encryptionMasterKey", function () {
   let pusher
 
-  const testMasterKey = "01234567890123456789012345678901"
+  const testMasterKeyBase64 = "zyrm8pvV2C9fJcBfhyXzvxbJVN/H7QLmbe0xJi1GhPU="
 
   beforeEach(function () {
     pusher = new Pusher({
       appId: 1234,
       key: "f00d",
       secret: "tofu",
-      encryptionMasterKey: testMasterKey,
+      encryptionMasterKeyBase64: testMasterKeyBase64,
     })
   })
 
-  describe("#auth", function () {
+  describe("#authorizeChannel", function () {
     it("should return a shared_secret for private-encrypted- channels", function () {
       expect(
-        pusher.authenticate("123.456", "private-encrypted-bla", "foo")
+        pusher.authorizeChannel("123.456", "private-encrypted-bla", "foo")
       ).to.eql({
         auth:
           "f00d:962c48b78bf93d98ff4c92ee7dff04865821455b7b401e9d60a9e0a90af2c105",
         channel_data: '"foo"',
-        shared_secret: "BYBsePpRCQkGPvbWu/5j8x+MmUF5sgPH5DmNBwkTzYs=",
+        shared_secret: "nlr49ISQHz91yS3cy/yWmW8wFMNeTnNL5tNHnbPJcLQ=",
       })
     })
     it("should not return a shared_secret for non-encrypted channels", function () {
-      expect(pusher.authenticate("123.456", "bla", "foo")).to.eql({
+      expect(pusher.authorizeChannel("123.456", "bla", "foo")).to.eql({
         auth:
           "f00d:013ad3da0d88e0df6ae0a8184bef50b9c3933f2344499e6e3d1ad67fad799e20",
         channel_data: '"foo"',

package/tests/integration/pusher/constructor.js

@@ -102,7 +102,7 @@ describe("Pusher", function () {
     it("should support `encryptionMasterKey` of 32 bytes", function () {
       const key = "01234567890123456789012345678901"
       const pusher = new Pusher({ encryptionMasterKey: key })
-      expect(pusher.config.encryptionMasterKey).to.equal(key)
+      expect(pusher.config.encryptionMasterKey.toString()).to.equal(key)
     })
 
     it("should reject `encryptionMasterKey` of 31 bytes", function () {
@@ -121,14 +121,14 @@ describe("Pusher", function () {
 
     it("should support `encryptionMasterKeyBase64` which decodes to 32 bytes", function () {
       const key = "01234567890123456789012345678901"
-      const keyBase64 = Buffer.from(key, "binary").toString("base64")
+      const keyBase64 = Buffer.from(key).toString("base64")
       const pusher = new Pusher({ encryptionMasterKeyBase64: keyBase64 })
-      expect(pusher.config.encryptionMasterKey).to.equal(key)
+      expect(pusher.config.encryptionMasterKey.toString()).to.equal(key)
     })
 
     it("should reject `encryptionMasterKeyBase64` which decodes to 31 bytes", function () {
       const key = "0123456789012345678901234567890"
-      const keyBase64 = Buffer.from(key, "binary").toString("base64")
+      const keyBase64 = Buffer.from(key).toString("base64")
       expect(function () {
         new Pusher({ encryptionMasterKeyBase64: keyBase64 })
       }).to.throwException(/31 bytes/)
@@ -136,7 +136,7 @@ describe("Pusher", function () {
 
     it("should reject `encryptionMasterKeyBase64` which decodes to 33 bytes", function () {
       const key = "012345678901234567890123456789012"
-      const keyBase64 = Buffer.from(key, "binary").toString("base64")
+      const keyBase64 = Buffer.from(key).toString("base64")
       expect(function () {
         new Pusher({ encryptionMasterKeyBase64: keyBase64 })
       }).to.throwException(/33 bytes/)

package/tests/integration/pusher/terminate.js

@@ -0,0 +1,55 @@
+const expect = require("expect.js")
+const nock = require("nock")
+
+const Pusher = require("../../../lib/pusher")
+const sinon = require("sinon")
+
+describe("Pusher", function () {
+  let pusher
+
+  beforeEach(function () {
+    pusher = new Pusher({ appId: 1234, key: "f00d", secret: "tofu" })
+    nock.disableNetConnect()
+  })
+
+  afterEach(function () {
+    nock.cleanAll()
+    nock.enableNetConnect()
+  })
+
+  describe("#terminateUserConnections", function () {
+    it("should throw an error if user id is empty", function () {
+      expect(function () {
+        pusher.terminateUserConnections("")
+      }).to.throwError(function (e) {
+        expect(e).to.be.an(Error)
+        expect(e.message).to.equal("Invalid user id: ''")
+      })
+    })
+
+    it("should throw an error if user id is not a string", function () {
+      expect(function () {
+        pusher.terminateUserConnections(123)
+      }).to.throwError(function (e) {
+        expect(e).to.be.an(Error)
+        expect(e.message).to.equal("Invalid user id: '123'")
+      })
+    })
+  })
+
+  it("should call /terminate_connections endpoint", function (done) {
+    sinon.stub(pusher, "post")
+    pusher.appId = 1234
+    const userId = "testUserId"
+
+    pusher.terminateUserConnections(userId)
+
+    expect(pusher.post.called).to.be(true)
+    expect(pusher.post.getCall(0).args[0]).eql({
+      path: `/users/${userId}/terminate_connections`,
+      body: {},
+    })
+    pusher.post.restore()
+    done()
+  })
+})

package/tests/integration/pusher/trigger.js

@@ -2,8 +2,10 @@ const expect = require("expect.js")
 const nock = require("nock")
 const nacl = require("tweetnacl")
 const naclUtil = require("tweetnacl-util")
+const sinon = require("sinon")
 
 const Pusher = require("../../../lib/pusher")
+const events = require("../../../lib/events")
 
 describe("Pusher", function () {
   let pusher
@@ -99,7 +101,7 @@ describe("Pusher", function () {
         .catch(done)
     })
 
-    it("should add socket_id to the request body", function (done) {
+    it("should add params to the request body", function (done) {
       nock("http://api.pusherapp.com")
         .filteringPath(function (path) {
           return path
@@ -107,18 +109,23 @@ describe("Pusher", function () {
             .replace(/auth_signature=[0-9a-f]{64}/, "auth_signature=Y")
         })
         .post(
-          "/apps/1234/events?auth_key=f00d&auth_timestamp=X&auth_version=1.0&body_md5=0478e1ed73804ae1be97cfa6554cf039&auth_signature=Y",
+          "/apps/1234/events?auth_key=f00d&auth_timestamp=X&auth_version=1.0&body_md5=2e4f053f1c325dedbe21abd8f1852b53&auth_signature=Y",
           {
             name: "my_event",
             data: '{"some":"data "}',
             channels: ["test_channel"],
             socket_id: "123.567",
+            info: "user_count,subscription_count",
           }
         )
         .reply(200, "{}")
 
+      const params = {
+        socket_id: "123.567",
+        info: "user_count,subscription_count",
+      }
       pusher
-        .trigger("test_channel", "my_event", { some: "data " }, "123.567")
+        .trigger("test_channel", "my_event", { some: "data " }, params)
         .then(() => done())
         .catch(done)
     })
@@ -131,20 +138,31 @@ describe("Pusher", function () {
             .replace(/auth_signature=[0-9a-f]{64}/, "auth_signature=Y")
         })
         .post(
-          "/apps/1234/events?auth_key=f00d&auth_timestamp=X&auth_version=1.0&body_md5=cf87d666b4a829a54fc44b313584b2d7&auth_signature=Y",
+          "/apps/1234/events?auth_key=f00d&auth_timestamp=X&auth_version=1.0&body_md5=d3a47b3241328a6432adf60c8e91b6fb&auth_signature=Y",
           {
             name: "my_event",
             data: '{"some":"data "}',
             channels: ["test_channel"],
+            info: "subscription_count",
           }
         )
-        .reply(200, "OK")
+        .reply(200, '{"channels":{"test_channel":{"subscription_count":123}}}')
 
       pusher
-        .trigger("test_channel", "my_event", { some: "data " })
+        .trigger(
+          "test_channel",
+          "my_event",
+          { some: "data " },
+          { info: "subscription_count" }
+        )
         .then((response) => {
           expect(response.status).to.equal(200)
-          done()
+          return response.text().then((body) => {
+            expect(body).to.equal(
+              '{"channels":{"test_channel":{"subscription_count":123}}}'
+            )
+            done()
+          })
         })
         .catch(done)
     })
@@ -286,7 +304,12 @@ describe("Pusher", function () {
         .reply(200, "{}")
 
       pusher
-        .trigger("test_channel", "my_event", { some: "data " }, "123.567")
+        .trigger(
+          "test_channel",
+          "my_event",
+          { some: "data " },
+          { socket_id: "123.567" }
+        )
         .then(() => done())
         .catch(done)
     })
@@ -317,7 +340,12 @@ describe("Pusher", function () {
         .reply(200)
 
       pusher
-        .trigger("test_channel", "my_event", { some: "data " }, "123.567")
+        .trigger(
+          "test_channel",
+          "my_event",
+          { some: "data " },
+          { socket_id: "123.567" }
+        )
         .catch((error) => {
           expect(error).to.be.a(Pusher.RequestError)
           expect(error.message).to.equal("Request failed with an error")
@@ -415,14 +443,53 @@ describe("Pusher", function () {
         .catch(done)
     })
   })
+
+  describe("#sendToUser", function () {
+    it("should trigger an event on #server-to-user-{userId}", function () {
+      sinon.stub(events, "trigger")
+      pusher.sendToUser("abc123", "halo", { foo: "bar" })
+      expect(events.trigger.called).to.be(true)
+      expect(events.trigger.getCall(0).args[1]).eql(["#server-to-user-abc123"])
+      expect(events.trigger.getCall(0).args[2]).equal("halo")
+      expect(events.trigger.getCall(0).args[3]).eql({ foo: "bar" })
+      events.trigger.restore()
+    })
+
+    it("should throw an error if user id is empty", function () {
+      expect(function () {
+        pusher.sendToUser("", "halo", { foo: "bar" })
+      }).to.throwError(function (e) {
+        expect(e).to.be.an(Error)
+        expect(e.message).to.equal("Invalid user id: ''")
+      })
+    })
+
+    it("should throw an error if user id is not a string", function () {
+      expect(function () {
+        pusher.sendToUser(123, "halo", { foo: "bar" })
+      }).to.throwError(function (e) {
+        expect(e).to.be.an(Error)
+        expect(e.message).to.equal("Invalid user id: '123'")
+      })
+    })
+
+    it("should throw an error if event name is longer than 200 characters", function () {
+      const event = new Array(202).join("x") // 201 characters
+      expect(function () {
+        pusher.sendToUser("abc123", event, { foo: "bar" })
+      }).to.throwError(function (e) {
+        expect(e).to.be.an(Error)
+        expect(e.message).to.equal("Too long event name: '" + event + "'")
+      })
+    })
+  })
 })
 
 describe("Pusher with encryptionMasterKey", function () {
   let pusher
 
   const testMasterKey = Buffer.from(
-    "01234567890123456789012345678901",
-    "binary"
+    "01234567890123456789012345678901"
   ).toString("base64")
 
   beforeEach(function () {

package/.travis.yml

@@ -1,20 +0,0 @@
-language: node_js
-jobs:
-  include:
-    - node_js: 14
-      script:
-        - npm run lint
-        - npm test
-    - node_js: 12
-      script:
-        - npm run lint
-        - npm test
-    - node_js: 10
-      script:
-        - npm run lint
-        - npm test
-    - node_js: 8
-      script:
-        # eslint doesn't support node 8, but it's sufficient to check that the
-        # tests pass.
-        - npm test