pusher-js 7.4.1 → 7.6.0

package/spec/javascripts/unit/web/pusher_authorizer_spec.js

@@ -33,4 +33,32 @@ describe('JSONP Authorizer', function() {
       'To send headers with the channel-authorization request, you must use AJAX, rather than JSONP.'
     );
   });
+
+  it('should raise a warning if headersProvider is passed', function() {
+    var headers = { foo: 'bar', n: 42 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'jsonp',
+      headersProvider:  () => headers
+    })
+
+    var document = Mocks.getDocument();
+    var script = Mocks.getDocumentElement();
+    var documentElement = Mocks.getDocumentElement();
+
+    document.createElement.and.returnValue(script);
+    document.getElementsByTagName.and.returnValue([]);
+    document.documentElement = documentElement;
+    spyOn(Runtime, 'getDocument').and.returnValue(document);
+
+    spyOn(Logger, 'warn');
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan',
+    }, function() {})
+
+    expect(Logger.warn).toHaveBeenCalledWith(
+      'To send headers with the channel-authorization request, you must use AJAX, rather than JSONP.'
+    );
+  });
+
 });

package/spec/javascripts/unit/worker/channel_authorizer_spec.js

@@ -35,6 +35,30 @@ describe('Fetch Authorizer', function() {
     expect(sentHeaders.get('n')).toEqual('42');
   });
 
+  it('should pass headers from headersProvider in the request', function() {
+    fetchMock.mock(endpoint, { body: { hello: 'world' } });
+
+    var headers = { foo: 'bar', n: 42 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'ajax',
+      endpoint: endpoint,
+      headersProvider: () => headers
+    });
+
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan'
+    }, function() {});
+
+    var lastCall = fetchMock.lastCall(endpoint)[0];
+    var sentHeaders = lastCall.headers;
+    expect(sentHeaders.get('Content-Type')).toEqual(
+      'application/x-www-form-urlencoded'
+    );
+    expect(sentHeaders.get('foo')).toEqual('bar');
+    expect(sentHeaders.get('n')).toEqual('42');
+  });
+
   it('should pass params in the query string', async function() {
     fetchMock.mock(endpoint, { body: { hello: 'world' } });
 
@@ -56,6 +80,28 @@ describe('Fetch Authorizer', function() {
     expect(body).toEqual("socket_id=1.23&channel_name=chan&a=1&b=2");
   });
 
+  it('should pass params from paramsProvider in the query string', async function() {
+    fetchMock.mock(endpoint, { body: { hello: 'world' } });
+
+    var params = { a: 1, b: 2 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'ajax',
+      endpoint: endpoint,
+      paramsProvider: () => params
+    });
+
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan'
+    }, function() {});
+
+    await new Promise(resolve => setTimeout(resolve, 100));
+    var lastRequest = fetchMock.lastCall(endpoint)[0];
+    const body = await lastRequest.text()
+    expect(body).toEqual("socket_id=1.23&channel_name=chan&a=1&b=2");
+  });
+
+
   it('should call back with the auth result on success', async function() {
     var data = { foo: 'bar', number: 1 };
     var dataJSON = JSON.stringify(data);

package/src/core/auth/channel_authorizer.ts

@@ -16,12 +16,23 @@ const composeChannelQuery = (
 
   query += '&channel_name=' + encodeURIComponent(params.channelName);
 
-  for (var i in authOptions.params) {
+  for (var key in authOptions.params) {
     query +=
       '&' +
-      encodeURIComponent(i) +
+      encodeURIComponent(key) +
       '=' +
-      encodeURIComponent(authOptions.params[i]);
+      encodeURIComponent(authOptions.params[key]);
+  }
+
+  if (authOptions.paramsProvider != null) {
+    let dynamicParams = authOptions.paramsProvider();
+    for (var key in dynamicParams) {
+      query +=
+        '&' +
+        encodeURIComponent(key) +
+        '=' +
+        encodeURIComponent(dynamicParams[key]);
+    }
   }
 
   return query;

package/src/core/auth/options.ts

@@ -56,6 +56,8 @@ export interface AuthOptionsT<AuthHandler> {
   endpoint: string;
   params?: any;
   headers?: any;
+  paramsProvider?: () => any;
+  headersProvider?: () => any;
   customHandler?: AuthHandler;
 }
 
@@ -71,4 +73,6 @@ export interface InternalAuthOptions {
   endpoint: string;
   params?: any;
   headers?: any;
+  paramsProvider?: () => any;
+  headersProvider?: () => any;
 }

package/src/core/auth/user_authenticator.ts

@@ -14,12 +14,23 @@ const composeChannelQuery = (
 ) => {
   var query = 'socket_id=' + encodeURIComponent(params.socketId);
 
-  for (var i in authOptions.params) {
+  for (var key in authOptions.params) {
     query +=
       '&' +
-      encodeURIComponent(i) +
+      encodeURIComponent(key) +
       '=' +
-      encodeURIComponent(authOptions.params[i]);
+      encodeURIComponent(authOptions.params[key]);
+  }
+
+  if (authOptions.paramsProvider != null) {
+    let dynamicParams = authOptions.paramsProvider();
+    for (var key in dynamicParams) {
+      query +=
+        '&' +
+        encodeURIComponent(key) +
+        '=' +
+        encodeURIComponent(dynamicParams[key]);
+    }
   }
 
   return query;

package/src/core/pusher.ts

@@ -62,7 +62,6 @@ export default class Pusher {
   connection: ConnectionManager;
   timelineSenderTimer: PeriodicTimer;
   user: UserFacade;
-
   constructor(app_key: string, options?: Options) {
     checkAppKey(app_key);
     options = options || {};

package/src/core/user.ts

@@ -5,6 +5,7 @@ import {
   UserAuthenticationCallback
 } from './auth/options';
 import Channel from './channels/channel';
+import WatchlistFacade from './watchlist';
 import EventsDispatcher from './events/dispatcher';
 import flatPromise from './utils/flat_promise';
 
@@ -14,6 +15,7 @@ export default class UserFacade extends EventsDispatcher {
   user_data: any = null;
   serverToUserChannel: Channel = null;
   signinDonePromise: Promise<any> = null;
+  watchlist: WatchlistFacade;
   private _signinDoneResolve: Function = null;
 
   public constructor(pusher: Pusher) {
@@ -30,6 +32,9 @@ export default class UserFacade extends EventsDispatcher {
         this._newSigninPromiseIfNeeded();
       }
     });
+
+    this.watchlist = new WatchlistFacade(pusher);
+
     this.pusher.connection.bind('message', event => {
       var eventName = event.event;
       if (eventName === 'pusher:signin_success') {

package/src/core/watchlist.ts

@@ -0,0 +1,31 @@
+import Logger from './logger';
+import Pusher from './pusher';
+import EventsDispatcher from './events/dispatcher';
+
+export default class WatchlistFacade extends EventsDispatcher {
+  private pusher: Pusher;
+
+  public constructor(pusher: Pusher) {
+    super(function(eventName, data) {
+      Logger.debug(`No callbacks on watchlist events for ${eventName}`);
+    });
+
+    this.pusher = pusher;
+    this.bindWatchlistInternalEvent();
+  }
+
+  handleEvent(pusherEvent) {
+    pusherEvent.data.events.forEach(watchlistEvent => {
+      this.emit(watchlistEvent.name, watchlistEvent);
+    });
+  }
+
+  private bindWatchlistInternalEvent() {
+    this.pusher.connection.bind('message', pusherEvent => {
+      var eventName = pusherEvent.event;
+      if (eventName === 'pusher_internal:watchlist_events') {
+        this.handleEvent(pusherEvent);
+      }
+    });
+  }
+}

package/src/runtimes/isomorphic/auth/xhr_auth.ts

@@ -27,6 +27,12 @@ const ajax: AuthTransport = function(
   for (var headerName in authOptions.headers) {
     xhr.setRequestHeader(headerName, authOptions.headers[headerName]);
   }
+  if (authOptions.headersProvider != null) {
+    let dynamicHeaders = authOptions.headersProvider();
+    for (var headerName in dynamicHeaders) {
+      xhr.setRequestHeader(headerName, dynamicHeaders[headerName]);
+    }
+  }
 
   xhr.onreadystatechange = function() {
     if (xhr.readyState === 4) {

package/src/runtimes/web/auth/jsonp_auth.ts

@@ -16,7 +16,10 @@ var jsonp: AuthTransport = function(
   authRequestType: AuthRequestType,
   callback: AuthTransportCallback
 ) {
-  if (authOptions.headers !== undefined) {
+  if (
+    authOptions.headers !== undefined ||
+    authOptions.headersProvider != null
+  ) {
     Logger.warn(
       `To send headers with the ${authRequestType.toString()} request, you must use AJAX, rather than JSONP.`
     );

package/src/runtimes/worker/auth/fetch_auth.ts

@@ -21,6 +21,13 @@ var fetchAuth: AuthTransport = function(
     headers.set(headerName, authOptions.headers[headerName]);
   }
 
+  if (authOptions.headersProvider != null) {
+    const dynamicHeaders = authOptions.headersProvider();
+    for (var headerName in dynamicHeaders) {
+      headers.set(headerName, dynamicHeaders[headerName]);
+    }
+  }
+
   var body = query;
   var request = new Request(authOptions.endpoint, {
     headers,

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

@@ -32,6 +32,8 @@ export interface AuthOptionsT<AuthHandler> {
     endpoint: string;
     params?: any;
     headers?: any;
+    paramsProvider?: () => any;
+    headersProvider?: () => any;
     customHandler?: AuthHandler;
 }
 export declare type UserAuthenticationOptions = AuthOptionsT<UserAuthenticationHandler>;
@@ -41,4 +43,6 @@ export interface InternalAuthOptions {
     endpoint: string;
     params?: any;
     headers?: any;
+    paramsProvider?: () => any;
+    headersProvider?: () => any;
 }

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

@@ -1,5 +1,6 @@
 import Pusher from './pusher';
 import Channel from './channels/channel';
+import WatchlistFacade from './watchlist';
 import EventsDispatcher from './events/dispatcher';
 export default class UserFacade extends EventsDispatcher {
     pusher: Pusher;
@@ -7,6 +8,7 @@ export default class UserFacade extends EventsDispatcher {
     user_data: any;
     serverToUserChannel: Channel;
     signinDonePromise: Promise<any>;
+    watchlist: WatchlistFacade;
     private _signinDoneResolve;
     constructor(pusher: Pusher);
     signin(): void;

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

@@ -0,0 +1,8 @@
+import Pusher from './pusher';
+import EventsDispatcher from './events/dispatcher';
+export default class WatchlistFacade extends EventsDispatcher {
+    private pusher;
+    constructor(pusher: Pusher);
+    handleEvent(pusherEvent: any): void;
+    private bindWatchlistInternalEvent;
+}