pusher-js 7.3.0 → 7.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pusher-js",
-  "version": "7.3.0",
+  "version": "7.4.0",
   "description": "Pusher Channels JavaScript library for browsers, React Native, NodeJS and web workers",
   "main": "dist/node/pusher.js",
   "browser": "dist/web/pusher.js",
@@ -38,7 +38,7 @@
     "faye-websocket": "^0.11.3",
     "fetch-mock": "git+https://git@github.com/jpatel531/fetch-mock.git",
     "isomorphic-fetch": "^3.0.0",
-    "jasmine": "^3.8.0",
+    "jasmine": "^3.99.0",
     "jasmine-spec-reporter": "^7.0.0",
     "karma": "^6.4.0",
     "karma-browserstack-launcher": "^1.6.0",
@@ -54,7 +54,7 @@
     "prettier": "^1.19.1",
     "source-map-loader": "^1.1.3",
     "ts-loader": "^6.0.4",
-    "typescript": "^3.4.5",
+    "typescript": "^3.9.0",
     "uglify-js": "^2.6.2",
     "webpack": "^4.46.0",
     "webpack-cli": "^3.3.12",
@@ -63,6 +63,7 @@
     "xmlhttprequest": "^1.8.0"
   },
   "dependencies": {
-    "tweetnacl": "^1.0.3"
+    "tweetnacl": "^1.0.3",
+    "@types/node": "^14.14.31"
   }
 }

package/spec/javascripts/helpers/timers/promises.js

@@ -0,0 +1,9 @@
+
+const setTimeoutPromise = (duration) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, duration);
+    });
+}
+export default {
+    setTimeout: setTimeoutPromise
+};

package/spec/javascripts/unit/core/channels/presence_channel_spec.js

@@ -4,6 +4,8 @@ var Members = require('core/channels/members').default;
 var Errors = require('core/errors');
 var Factory = require('core/utils/factory').default;
 var Mocks = require("mocks");
+var flatPromise = require("core/utils/flat_promise").default;
+var { setTimeout } = require("../../../helpers/timers/promises").default;
 
 describe("PresenceChannel", function() {
   var pusher;
@@ -47,7 +49,7 @@ describe("PresenceChannel", function() {
   });
 
   describe("#authorize", function() {
-    
+
     it("should call channelAuthorizer", function() {
       const callback = function(){}
       channel.authorize("1.23", callback);
@@ -56,30 +58,97 @@ describe("PresenceChannel", function() {
         { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
     });
 
-    it("should call the callback if an authorizaiton error is encountered", function() {
+    it("should call the callback if an authorization error is encountered", function() {
       const callback = jasmine.createSpy("callback")
       channel.authorize("1.23", callback);
       expect(channelAuthorizer.calls.count()).toEqual(1);
       expect(channelAuthorizer).toHaveBeenCalledWith(
         { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
       const presenceChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
-      
+
       presenceChannelCallback("error", {})
       expect(callback).toHaveBeenCalledWith("error", {})
     });
 
-    it("should call the callback with error if auth data doesn't have channel_data", function() {
-      const callback = jasmine.createSpy("callback")
-      channel.authorize("1.23", callback);
-      expect(channelAuthorizer.calls.count()).toEqual(1);
-      expect(channelAuthorizer).toHaveBeenCalledWith(
-        { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
-      const presenceChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
-      
-      presenceChannelCallback(null, {
-        foo: 'bar'
-      })
-      expect(callback).toHaveBeenCalledWith("Invalid auth response")
+    describe("when channel_data isn't present", function() {
+      let callback;
+      let presenceChannelCallback;
+      const authWithoutChannelData = {foo: 'bar'}
+
+      beforeEach(function() {
+        pusher.user = jasmine.createSpy("user");
+
+        callback = jasmine.createSpy("callback")
+        channel.authorize("1.23", callback);
+        expect(channelAuthorizer.calls.count()).toEqual(1);
+        expect(channelAuthorizer).toHaveBeenCalledWith(
+          { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
+        presenceChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
+      });
+
+      it("should call the callback with an error if no signin is in progress", async function() {
+        pusher.user.signinDonePromise = null;
+
+        presenceChannelCallback(null, authWithoutChannelData);
+        await setTimeout(10);
+        expect(callback).toHaveBeenCalledWith("Invalid auth response");
+      });
+
+      it("should wait for the in-progress sign in and call the callback with an error if signin failed", async function() {
+        const {promise, resolve} = flatPromise();
+        pusher.user.signinDonePromise = promise
+
+        // signin is in progress
+        presenceChannelCallback(null, authWithoutChannelData)
+        await setTimeout(10);
+        expect(callback).not.toHaveBeenCalled()
+
+        // Signin failed
+        pusher.user.user_data = null
+        resolve()
+        await setTimeout(10);
+        expect(callback).toHaveBeenCalledWith("Invalid auth response")
+      });
+
+      it("should wait for the in-progress sign in and call the callback if signin succeeded", async function() {
+        const {promise, resolve} = flatPromise();
+        pusher.user.signinDonePromise = promise
+
+        // signin is in progress
+        presenceChannelCallback(null, authWithoutChannelData)
+        await setTimeout(10);
+        expect(callback).not.toHaveBeenCalled()
+
+        // Signin succeeded
+        pusher.user.user_data = {id: '123'}
+        resolve()
+        await setTimeout(10);
+        expect(callback).toHaveBeenCalledWith(null, authWithoutChannelData)
+      });
+
+      it("should call the callback if the user is already signed in", async function() {
+        const {promise, resolve} = flatPromise();
+        pusher.user.signinDonePromise = promise
+        resolve()
+        pusher.user.user_data = {id: '123'}
+
+        // signin is in progress
+        presenceChannelCallback(null, authWithoutChannelData)
+        await setTimeout(10);
+        expect(callback).toHaveBeenCalledWith(null, authWithoutChannelData)
+      });
+
+      it("should call the callback with an error if the user signin already failed", async function() {
+        const {promise, resolve} = flatPromise();
+        pusher.user.signinDonePromise = promise
+        resolve()
+        pusher.user.user_data = null
+
+        // signin is in progress
+        presenceChannelCallback(null, authWithoutChannelData)
+        await setTimeout(10);
+        expect(callback).toHaveBeenCalledWith("Invalid auth response")
+      });
     });
 
     it("should call the callback with auth data", function() {
@@ -89,7 +158,7 @@ describe("PresenceChannel", function() {
       expect(channelAuthorizer).toHaveBeenCalledWith(
         { socketId: "1.23", channelName: "presence-test" }, jasmine.any(Function));
       const presenceChannelCallback = channelAuthorizer.calls.mostRecent().args[1];
-      
+
       const authdata = {
         channel_data: "{\"user_id\":\"123\"}",
         foo: 'bar'

package/spec/javascripts/unit/core/user_spec.js

@@ -82,7 +82,7 @@ describe("Pusher (User)", function () {
       });
 
       pusher.connection.state = "connected";
-      pusher.connection.emit('connected');
+      pusher.connection.emit('state_change', {previous:'connecting', current:'connected'});
 
       expect(pusher.config.userAuthenticator).toHaveBeenCalledWith(
         { socketId: "1.23" },
@@ -116,11 +116,11 @@ describe("Pusher (User)", function () {
       pusher.config.userAuthenticator.calls.reset()
 
       pusher.connection.state == "disconnected";
-      pusher.connection.emit("disconnected");
+      pusher.connection.emit('state_change', {previous:'connected', current:'disconnected'});
       pusher.connection.state == "connecting";
-      pusher.connection.emit("connecting");
+      pusher.connection.emit('state_change', {previous:'disconnected', current:'connecting'});
       pusher.connection.state == "connected";
-      pusher.connection.emit("connected");
+      pusher.connection.emit('state_change', {previous:'connecting', current:'connected'});
 
       expect(pusher.config.userAuthenticator).toHaveBeenCalledWith(
         { socketId: "1.23" },
@@ -134,7 +134,7 @@ describe("Pusher (User)", function () {
 
     it("should not signin when the connection is connected if signin() was never called", function () {
       pusher.connection.state = "connected";
-      pusher.connection.emit('connected');
+      pusher.connection.emit('state_change', {previous:'connecting', current:'connected'});
       expect(pusher.config.userAuthenticator).not.toHaveBeenCalled();
     })
 
@@ -172,6 +172,7 @@ describe("Pusher (User)", function () {
     });
 
     it('should process pusher:signin_success', async function () {
+      pusher.user._signinDoneResolve = jasmine.createSpy('signinDoneResolve');
       transport.emit('message', {
         data: JSON.stringify({
           event: 'pusher:signin_success',
@@ -183,6 +184,7 @@ describe("Pusher (User)", function () {
 
       expect(pusher.user.user_data).toEqual({ id: '1', name: 'test' });
       expect(pusher.user.serverToUserChannel.subscriptionPending).toBe(true);
+      expect(pusher.user._signinDoneResolve).toHaveBeenCalled();
     });
 
     it('should log warning if user_data is not JSON', async function () {
@@ -220,6 +222,7 @@ describe("Pusher (User)", function () {
       expect(barCallback).not.toHaveBeenCalled();
 
       // Sign in successfully
+      pusher.user._signinDoneResolve = jasmine.createSpy('signinDoneResolve');
       transport.emit('message', {
         data: JSON.stringify({
           event: 'pusher:signin_success',
@@ -242,6 +245,7 @@ describe("Pusher (User)", function () {
         'pusher.user.serverToUserChannel.subscribed to be true',
         500
       );
+      expect(pusher.user._signinDoneResolve).toHaveBeenCalled();
 
       // Send events on channel
       transport.emit('message', {
@@ -259,6 +263,7 @@ describe("Pusher (User)", function () {
 
     it('should cleanup the signed in state when disconnected', async function () {
       // Sign in successfully
+      pusher.user._signinDoneResolve = jasmine.createSpy('signinDoneResolve');
       transport.emit('message', {
         data: JSON.stringify({
           event: 'pusher:signin_success',
@@ -281,11 +286,13 @@ describe("Pusher (User)", function () {
         'pusher.user.serverToUserChannel.subscribed to be true',
         500
       );
+      expect(pusher.user._signinDoneResolve).toHaveBeenCalled();
+
       expect(pusher.user.user_data).toEqual({ id: '1', name: 'test' });
       expect(pusher.user.serverToUserChannel.subscribed).toBe(true);
 
       // Disconnect
-      pusher.connection.emit('disconnected');
+      pusher.connection.emit('state_change', {previous:'connected', current:'disconnected'});
 
       expect(pusher.user.user_data).toEqual(null);
       expect(pusher.user.serverToUserChannel).toEqual(null);

package/src/core/channels/presence_channel.ts

@@ -20,26 +20,35 @@ export default class PresenceChannel extends PrivateChannel {
     this.members = new Members();
   }
 
-  /** Authenticates the connection as a member of the channel.
+  /** Authorizes the connection as a member of the channel.
    *
    * @param  {String} socketId
    * @param  {Function} callback
    */
   authorize(socketId: string, callback: Function) {
-    super.authorize(socketId, (error, authData) => {
+    super.authorize(socketId, async (error, authData) => {
       if (!error) {
         authData = authData as ChannelAuthorizationData;
-        if (authData.channel_data === undefined) {
-          let suffix = UrlStore.buildLogSuffix('authenticationEndpoint');
-          Logger.error(
-            `Invalid auth response for channel '${this.name}',` +
-              `expected 'channel_data' field. ${suffix}`
-          );
-          callback('Invalid auth response');
-          return;
+        if (authData.channel_data != null) {
+          var channelData = JSON.parse(authData.channel_data);
+          this.members.setMyID(channelData.user_id);
+        } else {
+          await this.pusher.user.signinDonePromise;
+          if (this.pusher.user.user_data != null) {
+            // If the user is signed in, get the id of the authenticated user
+            // and allow the presence authorization to continue.
+            this.members.setMyID(this.pusher.user.user_data.id);
+          } else {
+            let suffix = UrlStore.buildLogSuffix('authorizationEndpoint');
+            Logger.error(
+              `Invalid auth response for channel '${this.name}', ` +
+                `expected 'channel_data' field. ${suffix}, ` +
+                `or the user should be signed in.`
+            );
+            callback('Invalid auth response');
+            return;
+          }
         }
-        var channelData = JSON.parse(authData.channel_data);
-        this.members.setMyID(channelData.user_id);
       }
       callback(error, authData);
     });

package/src/core/http/http_socket.ts

@@ -204,14 +204,16 @@ function replaceHost(url: string, hostname: string): string {
 }
 
 function randomNumber(max: number): number {
-  return Math.floor(Math.random() * max);
+  return Runtime.randomInt(max);
 }
 
 function randomString(length: number): string {
   var result = [];
+
   for (var i = 0; i < length; i++) {
     result.push(randomNumber(32).toString(32));
   }
+
   return result.join('');
 }
 

package/src/core/pusher.ts

@@ -83,7 +83,7 @@ export default class Pusher {
 
     this.channels = Factory.createChannels();
     this.global_emitter = new EventsDispatcher();
-    this.sessionID = Math.floor(Math.random() * 1000000000);
+    this.sessionID = Runtime.randomInt(1000000000);
 
     this.timeline = new Timeline(this.key, this.sessionID, {
       cluster: this.config.cluster,

package/src/core/user.ts

@@ -6,26 +6,29 @@ import {
 } from './auth/options';
 import Channel from './channels/channel';
 import EventsDispatcher from './events/dispatcher';
+import flatPromise from './utils/flat_promise';
 
 export default class UserFacade extends EventsDispatcher {
   pusher: Pusher;
   signin_requested: boolean = false;
   user_data: any = null;
   serverToUserChannel: Channel = null;
+  signinDonePromise: Promise<any> = null;
+  private _signinDoneResolve: Function = null;
 
   public constructor(pusher: Pusher) {
     super(function(eventName, data) {
       Logger.debug('No callbacks on user for ' + eventName);
     });
     this.pusher = pusher;
-    this.pusher.connection.bind('connected', () => {
-      this._signin();
-    });
-    this.pusher.connection.bind('connecting', () => {
-      this._disconnect();
-    });
-    this.pusher.connection.bind('disconnected', () => {
-      this._disconnect();
+    this.pusher.connection.bind('state_change', ({ previous, current }) => {
+      if (previous !== 'connected' && current === 'connected') {
+        this._signin();
+      }
+      if (previous === 'connected' && current !== 'connected') {
+        this._cleanup();
+        this._newSigninPromiseIfNeeded();
+      }
     });
     this.pusher.connection.bind('message', event => {
       var eventName = event.event;
@@ -55,41 +58,45 @@ export default class UserFacade extends EventsDispatcher {
       return;
     }
 
+    this._newSigninPromiseIfNeeded();
+
     if (this.pusher.connection.state !== 'connected') {
       // Signin will be attempted when the connection is connected
       return;
     }
 
-    const onAuthorize: UserAuthenticationCallback = (
-      err,
-      authData: UserAuthenticationData
-    ) => {
-      if (err) {
-        Logger.warn(`Error during signin: ${err}`);
-        return;
-      }
-
-      this.pusher.send_event('pusher:signin', {
-        auth: authData.auth,
-        user_data: authData.user_data
-      });
-
-      // Later when we get pusher:singin_success event, the user will be marked as signed in
-    };
-
     this.pusher.config.userAuthenticator(
       {
         socketId: this.pusher.connection.socket_id
       },
-      onAuthorize
+      this._onAuthorize
     );
   }
 
+  private _onAuthorize: UserAuthenticationCallback = (
+    err,
+    authData: UserAuthenticationData
+  ) => {
+    if (err) {
+      Logger.warn(`Error during signin: ${err}`);
+      this._cleanup();
+      return;
+    }
+
+    this.pusher.send_event('pusher:signin', {
+      auth: authData.auth,
+      user_data: authData.user_data
+    });
+
+    // Later when we get pusher:singin_success event, the user will be marked as signed in
+  };
+
   private _onSigninSuccess(data: any) {
     try {
       this.user_data = JSON.parse(data.user_data);
     } catch (e) {
       Logger.error(`Failed parsing user data after signin: ${data.user_data}`);
+      this._cleanup();
       return;
     }
 
@@ -97,9 +104,12 @@ export default class UserFacade extends EventsDispatcher {
       Logger.error(
         `user_data doesn't contain an id. user_data: ${this.user_data}`
       );
+      this._cleanup();
       return;
     }
 
+    // Signin succeeded
+    this._signinDoneResolve();
     this._subscribeChannels();
   }
 
@@ -132,12 +142,40 @@ export default class UserFacade extends EventsDispatcher {
     ensure_subscribed(this.serverToUserChannel);
   }
 
-  private _disconnect() {
+  private _cleanup() {
     this.user_data = null;
     if (this.serverToUserChannel) {
       this.serverToUserChannel.unbind_all();
       this.serverToUserChannel.disconnect();
       this.serverToUserChannel = null;
     }
+
+    if (this.signin_requested) {
+      // If signin is in progress and cleanup is called,
+      // Mark the current signin process as done.
+      this._signinDoneResolve();
+    }
+  }
+
+  private _newSigninPromiseIfNeeded() {
+    if (!this.signin_requested) {
+      return;
+    }
+
+    // If there is a promise and it is not resolved, return without creating a new one.
+    if (this.signinDonePromise && !(this.signinDonePromise as any).done) {
+      return;
+    }
+
+    // This promise is never rejected.
+    // It gets resolved when the signin process is done whether it failed or succeeded
+    const { promise, resolve, reject: _ } = flatPromise();
+    (promise as any).done = false;
+    const setDone = () => {
+      (promise as any).done = true;
+    };
+    promise.then(setDone).catch(setDone);
+    this.signinDonePromise = promise;
+    this._signinDoneResolve = resolve;
   }
 }

package/src/core/utils/flat_promise.ts

@@ -0,0 +1,10 @@
+function flatPromise() {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+export default flatPromise;

package/src/runtimes/interface.ts

@@ -46,6 +46,7 @@ interface Runtime {
   HTTPFactory: HTTPFactory;
   isXHRSupported(): boolean;
   createSocketRequest(method: string, url: string): HTTPRequest;
+  randomInt(max: number): number;
 
   // these methods/types are only implemented in the web Runtime, so they're
   // optional but must be included in the interface

package/src/runtimes/node/runtime.ts

@@ -6,6 +6,7 @@ import { Network } from './net_info';
 import xhrAuth from 'isomorphic/auth/xhr_auth';
 import { AuthTransports } from 'core/auth/auth_transports';
 import xhrTimeline from 'isomorphic/timeline/xhr_timeline';
+import { randomInt } from 'crypto';
 
 // Very verbose but until unavoidable until
 // TypeScript 2.1, when spread attributes will be
@@ -57,6 +58,10 @@ const NodeJS: Runtime = {
 
   getNetwork() {
     return Network;
+  },
+
+  randomInt(max: number): number {
+    return randomInt(max);
   }
 };
 

package/src/runtimes/react-native/runtime.ts

@@ -4,6 +4,7 @@ import { Network } from './net_info';
 import xhrAuth from 'isomorphic/auth/xhr_auth';
 import { AuthTransports } from 'core/auth/auth_transports';
 import xhrTimeline from 'isomorphic/timeline/xhr_timeline';
+import { randomInt } from 'crypto';
 
 // Very verbose but until unavoidable until
 // TypeScript 2.1, when spread attributes will be
@@ -55,6 +56,10 @@ const ReactNative: Runtime = {
 
   getNetwork() {
     return Network;
+  },
+
+  randomInt(max: number): number {
+    return randomInt(max);
   }
 };
 

package/src/runtimes/web/runtime.ts

@@ -154,6 +154,20 @@ var Runtime: Browser = {
     } else if (window.detachEvent !== undefined) {
       window.detachEvent('onunload', listener);
     }
+  },
+
+  randomInt(max: number): number {
+    /**
+     * Return values in the range of [0, 1[
+     */
+    const random = function() {
+      const crypto = window.crypto || window['msCrypto'];
+      const random = crypto.getRandomValues(new Uint32Array(1))[0];
+
+      return random / 2 ** 32;
+    };
+
+    return Math.floor(random() * max);
   }
 };
 

package/src/runtimes/worker/runtime.ts

@@ -55,6 +55,20 @@ const Worker: Runtime = {
 
   getNetwork() {
     return Network;
+  },
+
+  randomInt(max: number): number {
+    /**
+     * Return values in the range of [0, 1[
+     */
+    const random = function() {
+      const crypto = window.crypto || window['msCrypto'];
+      const random = crypto.getRandomValues(new Uint32Array(1))[0];
+
+      return random / 2 ** 32;
+    };
+
+    return Math.floor(random() * max);
   }
 };
 

package/types/src/core/strategies/transport_strategy.d.ts

@@ -9,6 +9,9 @@ export default class TransportStrategy implements Strategy {
     constructor(name: string, priority: number, transport: Transport, options: StrategyOptions);
     isSupported(): boolean;
     connect(minPriority: number, callback: Function): {
+        abort: () => void;
+        forceMinPriority: () => void;
+    } | {
         abort: () => void;
         forceMinPriority: (p: any) => void;
     };

package/types/src/core/user.d.ts

@@ -6,10 +6,14 @@ export default class UserFacade extends EventsDispatcher {
     signin_requested: boolean;
     user_data: any;
     serverToUserChannel: Channel;
+    signinDonePromise: Promise<any>;
+    private _signinDoneResolve;
     constructor(pusher: Pusher);
     signin(): void;
     private _signin;
+    private _onAuthorize;
     private _onSigninSuccess;
     private _subscribeChannels;
-    private _disconnect;
+    private _cleanup;
+    private _newSigninPromiseIfNeeded;
 }

package/types/src/core/utils/flat_promise.d.ts

@@ -0,0 +1,6 @@
+declare function flatPromise(): {
+    promise: Promise<unknown>;
+    resolve: any;
+    reject: any;
+};
+export default flatPromise;

package/types/src/runtimes/interface.d.ts

@@ -33,6 +33,7 @@ interface Runtime {
     HTTPFactory: HTTPFactory;
     isXHRSupported(): boolean;
     createSocketRequest(method: string, url: string): HTTPRequest;
+    randomInt(max: number): number;
     getDocument?(): Document;
     createScriptRequest?(url: string): any;
     createJSONPRequest?(url: string, data: any): JSONPRequest;