pusher-js 8.4.2 → 8.5.0

package/integration_tests_server/package.json

@@ -9,7 +9,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "express": "^4.18.2",
+    "express": "^4.22.1",
+    "path-to-regexp": "^0.1.13",
     "pusher": "^5.1.1-beta"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pusher-js",
-  "version": "8.4.2",
+  "version": "8.5.0",
   "description": "Pusher Channels JavaScript library for browsers, React Native, NodeJS and web workers",
   "main": "dist/node/pusher.js",
   "browser": "dist/web/pusher.js",
@@ -50,31 +50,44 @@
     "karma-safari-launcher": "^1.0.0",
     "karma-spec-reporter": "0.0.32",
     "karma-verbose-reporter": "0.0.6",
-    "karma-webpack": "^4.0.2",
+    "karma-webpack": "^5.0.1",
     "prettier": "^3.4.2",
     "source-map-loader": "^1.1.3",
     "ts-loader": "^6.0.4",
     "typescript": "^5.1.3",
-    "uglify-js": "^2.6.2",
-    "webpack": "^4.46.0",
-    "webpack-cli": "^3.3.12",
-    "webpack-dev-server": "^4.11.1",
+    "uglify-js": "^3.19.3",
+    "webpack": "^5.105.4",
+    "webpack-cli": "^7.0.2",
+    "webpack-dev-server": "^5.2.3",
     "webpack-merge": "^5.8.0",
     "xmlhttprequest": "^1.8.0",
-    "@types/node": "^20.3.0",
+    "@types/node": "^25.5.0",
     "@types/express-serve-static-core": "4.17.28"
   },
   "dependencies": {
     "tweetnacl": "^1.0.3"
   },
   "overrides": {
+    "flatted": "^3.4.2",
+    "picomatch": "^2.3.2",
+    "body-parser": "^1.20.3",
+    "browserstack-local": "^1.5.12",
     "cipher-base": "^1.0.6",
     "compression": "^1.8.1",
+    "express": "^4.22.1",
     "js-yaml": "^3.14.2",
+    "lodash": "^4.17.23",
+    "minimatch": "^9.0.3",
+    "karma": {
+      "minimatch": "^3.1.2"
+    },
     "node-forge": "^1.3.2",
     "on-headers": "^1.1.0",
     "pbkdf2": "^3.1.5",
+    "qs": "^6.14.0",
     "sha.js": "^2.4.12",
-    "tmp": "^0.2.4"
+    "tmp": "^0.2.4",
+    "ws": "^7.5.10",
+    "json5": "^2.2.3"
   }
 }

package/spec/config/jasmine/webpack.integration.js

@@ -16,7 +16,7 @@ module.exports = merge({}, baseConfig, {
   output: {
     filename: "integration_tests_spec.js",
     path: path.join(__dirname, "..", "..", "..", "tmp", "node_integration"),
-    libraryTarget: "var"
+    library: { type: "var" }
   },
   resolve: {
     modules: ['spec/javascripts/helpers'],

package/spec/config/jasmine/webpack.unit.js

@@ -16,7 +16,7 @@ module.exports =  merge({}, baseConfig, {
   output: {
     filename: "unit_tests_spec.js",
     path: path.join(__dirname, "..", "..", "..", "tmp", "node_unit"),
-    libraryTarget: "var"
+    library: { type: "var" }
   },
   externals: {
     testenv: "'node'"

package/spec/config/karma/config.ci.js

@@ -1,25 +1,25 @@
 var config = {
-  browserStack: {
-    startTunnel: true,
-    timeout: 1800,
-  },
-  browsers: ['ChromeHeadless', 'FirefoxHeadless'],
+  browsers: ['ChromeHeadlessNoHttpsUpgrade', 'FirefoxHeadlessNoHttpsUpgrade'],
   customLaunchers: {
-    bs_safari_12: {
-      base: 'BrowserStack',
-      os_version: "Mojave",
-      browser: "Safari",
-      browser_version: "12",
-      os: "OS X"
+    // When forceTLS=true XHR tests run first, browsers store an HSTS entry for
+    // sockjs-*.pusher.com (Pusher servers send Strict-Transport-Security headers).
+    // Subsequent forceTLS=false XHR tests request HTTP URLs which are then
+    // silently upgraded to HTTPS via HSTS. The resulting CORS preflight for the
+    // upgraded URL fails, blocking the connection. Disabling web security (Chrome)
+    // or HTTPS-only mode (Firefox) bypasses this so the HSTS-upgraded HTTPS
+    // response is returned to the Pusher client and the connection can establish.
+    ChromeHeadlessNoHttpsUpgrade: {
+      base: 'ChromeHeadless',
+      flags: ['--disable-web-security']
+    },
+    FirefoxHeadlessNoHttpsUpgrade: {
+      base: 'FirefoxHeadless',
+      prefs: {
+        'dom.security.https_only_mode': false,
+        'network.stricttransportsecurity.preloadlist': false
+      }
     }
   }
 };
-if (process.env.CI === 'full' && browserStackCredsAvailable()) {
-  config.browsers.push('bs_safari_12');
-}
-
-function browserStackCredsAvailable() {
-  return process.env.BROWSER_STACK_USERNAME && process.env.BROWSER_STACK_ACCESS_KEY
-}
 
 module.exports = config;

package/spec/javascripts/helpers/mocks.js

@@ -245,6 +245,7 @@ var Mocks = {
     manager.disconnect = jasmine.createSpy("disconnect");
     manager.send_event = jasmine.createSpy("send_event");
     manager.isUsingTLS = jasmine.createSpy("isUsingTLS").and.returnValue(false);
+    manager.switchCluster = jasmine.createSpy("switchCluster");
     return manager;
   },
 

package/spec/javascripts/integration/index.web.js

@@ -59,5 +59,19 @@ function getTestConfigs() {
     testConfigs.push({ transport: "sockjs", forceTLS: true})
     testConfigs.push({ transport: "sockjs", forceTLS: false})
   }
+
+  // Test all forceTLS: false before forceTLS: true
+  // Because browsers prevent a URL from downgrading from HTTPS to HTTP
+  // This is probably the result of Strict-Transport-Security header returned when calling the HTTPS endpoint.
+  testConfigs.sort((a, b) => {
+    if (a.forceTLS == false && b.forceTLS == true) {
+      return -1;
+    } else if (a.forceTLS == true && b.forceTLS == false) {
+      return 1;
+    } else {
+      return 0;
+    }
+  })
+
   return testConfigs
 }

package/spec/javascripts/unit/core/connection/connection_manager_spec.js

@@ -116,6 +116,49 @@ describe("ConnectionManager", function() {
     });
   });
 
+  describe("#switchCluster", function() {
+    it("should update cluster key", function() {
+      expect(manager.key).toEqual("foo");
+      manager.switchCluster("bar");
+      expect(manager.key).toEqual("bar");
+    });
+
+    it("should re-build the strategy", function() {
+      expect(managerOptions.getStrategy.calls.count()).toEqual(1);
+      manager.switchCluster("bar");
+      expect(managerOptions.getStrategy.calls.count()).toEqual(2);
+      expect(managerOptions.getStrategy).toHaveBeenCalledWith({
+        key: "bar",
+        useTLS: false,
+        timeline: timeline
+      });
+    });
+
+    it("should try to connect using the strategy", function() {
+      manager.switchCluster("bar");
+      // connection is retried with a zero delay
+      jasmine.clock().tick(0);
+      expect(strategy.connect).toHaveBeenCalled();
+    });
+
+    it("should transition to connecting", function() {
+      var onConnecting = jasmine.createSpy("onConnecting");
+      var onStateChange = jasmine.createSpy("onStateChange");
+      manager.bind("connecting", onConnecting);
+      manager.bind("state_change", onStateChange);
+
+      manager.switchCluster("bar");// connection is retried with a zero delay
+      jasmine.clock().tick(0);
+
+      expect(manager.state).toEqual("connecting");
+      expect(onConnecting).toHaveBeenCalled();
+      expect(onStateChange).toHaveBeenCalledWith({
+        previous: "initialized",
+        current: "connecting"
+      });
+    });
+  });
+
   describe("before establishing a connection", function() {
     beforeEach(function() {
       manager.connect();

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

@@ -307,6 +307,64 @@ describe("Pusher", function() {
       });
     });
 
+    describe("switch cluster", function() {
+      var pusher;
+      var subscribedChannels
+
+      beforeEach(function() {
+        pusher = new Pusher("foo", {cluster: "mt1"});
+
+        subscribedChannels = {
+          channel1: pusher.subscribe("channel1"),
+          channel2: pusher.subscribe("channel2")
+        };
+
+        pusher.connect();
+        pusher.connection.state = "connected";
+        pusher.connection.emit("connected");
+      });
+
+      it("should resubscribe to all channels", function() {
+        expect(subscribedChannels.channel1.subscribe).toHaveBeenCalledTimes(1);
+        expect(subscribedChannels.channel2.subscribe).toHaveBeenCalledTimes(1);
+
+        pusher.switchCluster({ appKey: 'bar', cluster: 'us3' });
+        pusher.connect();
+        pusher.connection.state = 'connected';
+        pusher.connection.emit('connected');
+
+        expect(subscribedChannels.channel1.subscribe).toHaveBeenCalledTimes(2);
+        expect(subscribedChannels.channel2.subscribe).toHaveBeenCalledTimes(2);
+      });
+
+      it("should send events via the connection manager", function() {
+        pusher.switchCluster({ appKey: 'bar', cluster: 'us3' });
+        pusher.send_event("event", { key: "value" }, "channel");
+        expect(pusher.connection.send_event).toHaveBeenCalledWith(
+          "event",
+          { key: "value" },
+          "channel"
+        );
+      });
+
+      it('should keep the persist the previous options', () => {
+        var authorizeSpy = jasmine.createSpy("authorizeSpy");
+        const options = {
+          cluster: "mt1",
+          enableStats: true,
+          channelAuthorization: {
+            customHandler: authorizeSpy
+          }
+        };
+
+        var pusher = new Pusher("foo", options);
+        pusher.connect();
+        pusher.switchCluster({ appKey: 'bar', cluster: 'us3' });
+
+        expect(pusher.options).toEqual({ ...options, cluster: 'us3' });
+      })
+    })
+
     describe("#unsubscribe", function() {
       it("should unsubscribe the channel if subscription is not pending", function() {
         var channel = pusher.subscribe("yyy");

package/src/core/auth/options.ts

@@ -51,26 +51,24 @@ export type AuthTransportCallback =
   | ChannelAuthorizationCallback
   | UserAuthenticationCallback;
 
-export interface AuthOptionsT<AuthHandler> {
+export interface InternalAuthOptions {
   transport: 'ajax' | 'jsonp';
   endpoint: string;
   params?: any;
   headers?: any;
   paramsProvider?: () => any;
   headersProvider?: () => any;
-  customHandler?: AuthHandler;
 }
 
+export type CustomAuthOptions<AuthHandler> = {
+  customHandler: AuthHandler;
+};
+
+export type AuthOptionsT<AuthHandler> =
+  | InternalAuthOptions
+  | CustomAuthOptions<AuthHandler>;
+
 export declare type UserAuthenticationOptions =
   AuthOptionsT<UserAuthenticationHandler>;
 export declare type ChannelAuthorizationOptions =
   AuthOptionsT<ChannelAuthorizationHandler>;
-
-export interface InternalAuthOptions {
-  transport: 'ajax' | 'jsonp';
-  endpoint: string;
-  params?: any;
-  headers?: any;
-  paramsProvider?: () => any;
-  headersProvider?: () => any;
-}

package/src/core/config.ts

@@ -4,6 +4,8 @@ import {
   ChannelAuthorizationHandler,
   UserAuthenticationHandler,
   ChannelAuthorizationOptions,
+  AuthOptionsT,
+  CustomAuthOptions,
 } from './auth/options';
 import UserAuthenticator from './auth/user_authenticator';
 import ChannelAuthorizer from './auth/channel_authorizer';
@@ -131,15 +133,19 @@ function getEnableStatsConfig(opts: Options): boolean {
   return false;
 }
 
+const hasCustomHandler = <T>(
+  auth: AuthOptionsT<T>,
+): auth is CustomAuthOptions<T> => {
+  return 'customHandler' in auth && auth['customHandler'] != null;
+};
+
 function buildUserAuthenticator(opts: Options): UserAuthenticationHandler {
   const userAuthentication = {
     ...Defaults.userAuthentication,
     ...opts.userAuthentication,
   };
-  if (
-    'customHandler' in userAuthentication &&
-    userAuthentication['customHandler'] != null
-  ) {
+
+  if (hasCustomHandler(userAuthentication)) {
     return userAuthentication['customHandler'];
   }
 
@@ -158,17 +164,22 @@ function buildChannelAuth(opts: Options, pusher): ChannelAuthorizationOptions {
       transport: opts.authTransport || Defaults.authTransport,
       endpoint: opts.authEndpoint || Defaults.authEndpoint,
     };
+
     if ('auth' in opts) {
       if ('params' in opts.auth) channelAuthorization.params = opts.auth.params;
       if ('headers' in opts.auth)
         channelAuthorization.headers = opts.auth.headers;
     }
-    if ('authorizer' in opts)
-      channelAuthorization.customHandler = ChannelAuthorizerProxy(
-        pusher,
-        channelAuthorization,
-        opts.authorizer,
-      );
+
+    if ('authorizer' in opts) {
+      return {
+        customHandler: ChannelAuthorizerProxy(
+          pusher,
+          channelAuthorization,
+          opts.authorizer,
+        ),
+      };
+    }
   }
   return channelAuthorization;
 }
@@ -178,10 +189,8 @@ function buildChannelAuthorizer(
   pusher,
 ): ChannelAuthorizationHandler {
   const channelAuthorization = buildChannelAuth(opts, pusher);
-  if (
-    'customHandler' in channelAuthorization &&
-    channelAuthorization['customHandler'] != null
-  ) {
+
+  if (hasCustomHandler(channelAuthorization)) {
     return channelAuthorization['customHandler'];
   }
 

package/src/core/connection/connection_manager.ts

@@ -96,6 +96,15 @@ export default class ConnectionManager extends EventsDispatcher {
     this.updateStrategy();
   }
 
+  switchCluster(key: string) {
+    this.key = key;
+    // This ensures that the new config coming from
+    // pusher instance are taken into account
+    // such as appKey and cluster
+    this.updateStrategy();
+    this.retryIn(0);
+  }
+
   /** Establishes a connection to Pusher.
    *
    * Does nothing when connection is already established. See top-level doc

package/src/core/options.ts

@@ -44,6 +44,11 @@ export interface Options {
   wssPort?: number;
 }
 
+export interface ClusterOptions {
+  appKey: string;
+  cluster: string;
+}
+
 export function validateOptions(options) {
   if (options == null) {
     throw 'You must pass an options object';

package/src/core/pusher.ts

@@ -1,6 +1,5 @@
 import AbstractRuntime from '../runtimes/interface';
 import Runtime from 'runtime';
-import Util from './util';
 import * as Collections from './utils/collections';
 import Channels from './channels/channels';
 import Channel from './channels/channel';
@@ -10,14 +9,11 @@ import TimelineSender from './timeline/timeline_sender';
 import TimelineLevel from './timeline/level';
 import { defineTransport } from './strategies/strategy_builder';
 import ConnectionManager from './connection/connection_manager';
-import ConnectionManagerOptions from './connection/connection_manager_options';
 import { PeriodicTimer } from './utils/timers';
 import Defaults from './defaults';
-import * as DefaultConfig from './config';
 import Logger from './logger';
 import Factory from './utils/factory';
-import UrlStore from 'core/utils/url_store';
-import { Options, validateOptions } from './options';
+import { Options, ClusterOptions, validateOptions } from './options';
 import { Config, getConfig } from './config';
 import StrategyOptions from './strategies/strategy_options';
 import UserFacade from './user';
@@ -53,6 +49,7 @@ export default class Pusher {
 
   /* INSTANCE PROPERTIES */
   key: string;
+  options: Options;
   config: Config;
   channels: Channels;
   global_emitter: EventsDispatcher;
@@ -66,7 +63,8 @@ export default class Pusher {
     checkAppKey(app_key);
     validateOptions(options);
     this.key = app_key;
-    this.config = getConfig(options, this);
+    this.options = options;
+    this.config = getConfig(this.options, this);
 
     this.channels = Factory.createChannels();
     this.global_emitter = new EventsDispatcher();
@@ -141,6 +139,19 @@ export default class Pusher {
     }
   }
 
+  /**
+   * Allows you to switch Pusher cluster without
+   * losing all the channels/subscription binding
+   * as this is internally managed by the SDK.
+   */
+  switchCluster(options: ClusterOptions) {
+    const { appKey, cluster } = options;
+    this.key = appKey;
+    this.options = { ...this.options, cluster };
+    this.config = getConfig(this.options, this);
+    this.connection.switchCluster(this.key);
+  }
+
   channel(name: string): Channel {
     return this.channels.find(name);
   }

package/types/src/core/auth/options.d.ts

@@ -27,22 +27,17 @@ export interface UserAuthenticationHandler {
     (params: UserAuthenticationRequestParams, callback: UserAuthenticationCallback): void;
 }
 export type AuthTransportCallback = ChannelAuthorizationCallback | UserAuthenticationCallback;
-export interface AuthOptionsT<AuthHandler> {
+export interface InternalAuthOptions {
     transport: 'ajax' | 'jsonp';
     endpoint: string;
     params?: any;
     headers?: any;
     paramsProvider?: () => any;
     headersProvider?: () => any;
-    customHandler?: AuthHandler;
 }
+export type CustomAuthOptions<AuthHandler> = {
+    customHandler: AuthHandler;
+};
+export type AuthOptionsT<AuthHandler> = InternalAuthOptions | CustomAuthOptions<AuthHandler>;
 export declare type UserAuthenticationOptions = AuthOptionsT<UserAuthenticationHandler>;
 export declare type ChannelAuthorizationOptions = AuthOptionsT<ChannelAuthorizationHandler>;
-export interface InternalAuthOptions {
-    transport: 'ajax' | 'jsonp';
-    endpoint: string;
-    params?: any;
-    headers?: any;
-    paramsProvider?: () => any;
-    headersProvider?: () => any;
-}

package/types/src/core/connection/connection_manager.d.ts

@@ -24,6 +24,7 @@ export default class ConnectionManager extends EventsDispatcher {
     handshakeCallbacks: HandshakeCallbacks;
     connectionCallbacks: ConnectionCallbacks;
     constructor(key: string, options: ConnectionManagerOptions);
+    switchCluster(key: string): void;
     connect(): void;
     send(data: any): boolean;
     send_event(name: string, data: any, channel?: string): boolean;

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

@@ -31,4 +31,8 @@ export interface Options {
     wsPort?: number;
     wssPort?: number;
 }
+export interface ClusterOptions {
+    appKey: string;
+    cluster: string;
+}
 export declare function validateOptions(options: any): void;

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

@@ -6,7 +6,7 @@ import Timeline from './timeline/timeline';
 import TimelineSender from './timeline/timeline_sender';
 import ConnectionManager from './connection/connection_manager';
 import { PeriodicTimer } from './utils/timers';
-import { Options } from './options';
+import { Options, ClusterOptions } from './options';
 import { Config } from './config';
 import UserFacade from './user';
 export default class Pusher {
@@ -21,6 +21,7 @@ export default class Pusher {
     static log: (message: any) => void;
     private static getClientFeatures;
     key: string;
+    options: Options;
     config: Config;
     channels: Channels;
     global_emitter: EventsDispatcher;
@@ -31,6 +32,7 @@ export default class Pusher {
     timelineSenderTimer: PeriodicTimer;
     user: UserFacade;
     constructor(app_key: string, options: Options);
+    switchCluster(options: ClusterOptions): void;
     channel(name: string): Channel;
     allChannels(): Channel[];
     connect(): void;

package/webpack/config.node.js

@@ -8,8 +8,7 @@ module.exports = merge({}, configShared, {
     pusher: './src/core/pusher-with-encryption.js',
   },
   output: {
-    library: 'Pusher',
-    libraryTarget: 'commonjs2',
+    library: { name: 'Pusher', type: 'commonjs2' },
     path: path.join(__dirname, '../dist/node'),
     filename: 'pusher.js',
   },

package/webpack/config.react-native.js

@@ -12,8 +12,7 @@ module.exports = merge({}, configShared, {
     pusher: './src/core/pusher-with-encryption.js',
   },
   output: {
-    library: 'Pusher',
-    libraryTarget: 'commonjs2',
+    library: { name: 'Pusher', type: 'commonjs2' },
     path: path.join(__dirname, '../dist/react-native'),
     filename: 'pusher.js',
   },

package/webpack/config.shared.js

@@ -21,6 +21,12 @@ module.exports = {
     extensions: ['.webpack.js', '.web.js', '.ts', '.js'],
     // add runtimes for easier importing of isomorphic runtime modules
     modules: ['src', 'src/runtimes', 'node_modules'],
+    fallback: {
+      // nacl uses Buffer on node.js but has a different code path for the browser.
+      // We don't need webpack to include a Buffer polyfill when seeing the usage,
+      // as it won't be used.
+      buffer: false,
+    },
   },
   module: {
     rules: [
@@ -32,12 +38,6 @@ module.exports = {
       },
     ],
   },
-  node: {
-    // nacl uses Buffer on node.js but has a different code path for the browser.
-    // We don't need webpack to include a Buffer polyfill when seeing the usage,
-    // as it won't be used.
-    Buffer: false,
-  },
   plugins: [
     new webpack.BannerPlugin({ banner: banner, raw: true }),
     new webpack.DefinePlugin({

package/webpack/config.web.js

@@ -19,10 +19,9 @@ module.exports = merge({}, configShared, {
     pusher: entry,
   },
   output: {
-    library: 'Pusher',
+    library: { name: 'Pusher', type: 'umd' },
     path: path.join(__dirname, '../dist/web'),
     filename: filename,
-    libraryTarget: 'umd',
   },
   resolve: {
     modules: ['src/runtimes/web'],

package/webpack/config.worker.js

@@ -21,10 +21,9 @@ var config = merge(configShared, {
     pusher: entry,
   },
   output: {
-    library: 'Pusher',
+    library: { name: 'Pusher', type: 'umd' },
     path: path.join(__dirname, '../dist/worker'),
     filename: filename,
-    libraryTarget: 'umd',
     globalObject: 'this',
   },
   resolve: {

package/webpack/dev.server.js

@@ -4,14 +4,7 @@ var WebpackDevServer = require('webpack-dev-server');
 
 var port = parseInt(process.env.PORT) || 5555;
 
-config.entry.app = [
-  'webpack-dev-server/client?http://localhost:' + port + '/',
-  'webpack/hot/dev-server',
-];
-
 var compiler = webpack(config);
-var server = new WebpackDevServer(compiler, {
-  hot: true,
-});
+var server = new WebpackDevServer({ hot: true, port: port }, compiler);
 
-server.listen(port);
+server.start();