pusher-js 7.0.6 → 7.2.0

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

@@ -0,0 +1,110 @@
+var fetchAuth = require('worker/auth/fetch_auth').default;
+var Runtime = require('runtime').default;
+var fetchMock = require('fetch-mock');
+var ChannelAuthorizer = require('core/auth/channel_authorizer').default;
+
+var endpoint = 'http://example.org/pusher/auth';
+
+describe('Fetch Authorizer', function() {
+
+  afterEach(function() {
+    fetchMock.restore();
+  });
+
+  it('should pass headers in the request', function() {
+    fetchMock.mock(endpoint, { body: { hello: 'world' } });
+
+    var headers = { foo: 'bar', n: 42 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'ajax',
+      endpoint: endpoint,
+      headers: 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' } });
+
+    var params = { a: 1, b: 2 };
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'ajax',
+      endpoint: endpoint,
+      params: 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);
+
+    fetchMock.mock(endpoint, {
+      body: dataJSON
+    });
+
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'ajax',
+      endpoint: endpoint,
+    });
+
+    var callback = jasmine.createSpy('callback123');
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan'
+    }, callback);
+    
+    await new Promise(resolve => setTimeout(resolve, 100));
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback).toHaveBeenCalledWith(null, data);
+  });
+
+  it('should call back with an error if JSON is invalid', async function() {
+    var channelAuthorizer = ChannelAuthorizer({
+      transport: 'ajax',
+      endpoint: endpoint,
+    });
+
+    var invalidJSON = 'INVALID { "something": "something"}';
+    fetchMock.mock(endpoint, {
+      body: invalidJSON
+    });
+
+    var callback = jasmine.createSpy('callback456');
+    channelAuthorizer({
+      socketId: '1.23',
+      channelName: 'chan'
+    }, callback);
+
+    await new Promise(resolve => setTimeout(resolve, 200));
+    expect(callback.calls.count()).toEqual(1);
+    expect(callback).toHaveBeenCalledWith(
+      new Error('JSON returned from auth endpoint was invalid, yet status code was 200. ' +
+        'Data was: ' +
+        invalidJSON), 
+        null
+    );
+
+  });
+});

package/src/core/auth/auth_transports.ts

@@ -1,7 +1,14 @@
 import AbstractRuntime from '../../runtimes/interface';
+import { AuthRequestType, InternalAuthOptions } from './options';
 
 interface AuthTransport {
-  (context: AbstractRuntime, socketId: string, callback: Function): void;
+  (
+    context: AbstractRuntime,
+    query: string,
+    authOptions: InternalAuthOptions,
+    authRequestType: AuthRequestType,
+    callback: Function
+  ): void;
 }
 
 interface AuthTransports {

package/src/core/auth/channel_authorizer.ts

@@ -0,0 +1,53 @@
+import {
+  AuthRequestType,
+  InternalAuthOptions,
+  ChannelAuthorizationHandler,
+  ChannelAuthorizationRequestParams,
+  ChannelAuthorizationCallback
+} from './options';
+
+import Runtime from 'runtime';
+
+const composeChannelQuery = (
+  params: ChannelAuthorizationRequestParams,
+  authOptions: InternalAuthOptions
+) => {
+  var query = 'socket_id=' + encodeURIComponent(params.socketId);
+
+  query += '&channel_name=' + encodeURIComponent(params.channelName);
+
+  for (var i in authOptions.params) {
+    query +=
+      '&' +
+      encodeURIComponent(i) +
+      '=' +
+      encodeURIComponent(authOptions.params[i]);
+  }
+
+  return query;
+};
+
+const ChannelAuthorizer = (
+  authOptions: InternalAuthOptions
+): ChannelAuthorizationHandler => {
+  if (typeof Runtime.getAuthorizers()[authOptions.transport] === 'undefined') {
+    throw `'${authOptions.transport}' is not a recognized auth transport`;
+  }
+
+  return (
+    params: ChannelAuthorizationRequestParams,
+    callback: ChannelAuthorizationCallback
+  ) => {
+    const query = composeChannelQuery(params, authOptions);
+
+    Runtime.getAuthorizers()[authOptions.transport](
+      Runtime,
+      query,
+      authOptions,
+      AuthRequestType.ChannelAuthorization,
+      callback
+    );
+  };
+};
+
+export default ChannelAuthorizer;

package/src/core/auth/deprecated_channel_authorizer.ts

@@ -0,0 +1,58 @@
+import Channel from '../channels/channel';
+import {
+  ChannelAuthorizationCallback,
+  ChannelAuthorizationHandler,
+  ChannelAuthorizationRequestParams,
+  InternalAuthOptions
+} from './options';
+
+export interface DeprecatedChannelAuthorizer {
+  authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+}
+
+export interface ChannelAuthorizerGenerator {
+  (
+    channel: Channel,
+    options: DeprecatedAuthorizerOptions
+  ): DeprecatedChannelAuthorizer;
+}
+
+export interface DeprecatedAuthOptions {
+  params?: any;
+  headers?: any;
+}
+
+export interface DeprecatedAuthorizerOptions {
+  authTransport: 'ajax' | 'jsonp';
+  authEndpoint: string;
+  auth?: DeprecatedAuthOptions;
+}
+
+export const ChannelAuthorizerProxy = (
+  pusher,
+  authOptions: InternalAuthOptions,
+  channelAuthorizerGenerator: ChannelAuthorizerGenerator
+): ChannelAuthorizationHandler => {
+  const deprecatedAuthorizerOptions: DeprecatedAuthorizerOptions = {
+    authTransport: authOptions.transport,
+    authEndpoint: authOptions.endpoint,
+    auth: {
+      params: authOptions.params,
+      headers: authOptions.headers
+    }
+  };
+  return (
+    params: ChannelAuthorizationRequestParams,
+    callback: ChannelAuthorizationCallback
+  ) => {
+    const channel = pusher.channel(params.channelName);
+    // This line creates a new channel authorizer every time.
+    // In the past, this was only done once per channel and reused.
+    // We can do that again if we want to keep this behavior intact.
+    const channelAuthorizer: DeprecatedChannelAuthorizer = channelAuthorizerGenerator(
+      channel,
+      deprecatedAuthorizerOptions
+    );
+    channelAuthorizer.authorize(params.socketId, callback);
+  };
+};

package/src/core/auth/options.ts

@@ -1,32 +1,67 @@
-import Channel from '../channels/channel';
-
-export interface AuthOptions {
-  params?: any;
-  headers?: any;
+export enum AuthRequestType {
+  UserAuthentication = 'user-authentication',
+  ChannelAuthorization = 'channel-authorization'
 }
 
-export interface AuthData {
+export interface ChannelAuthorizationData {
   auth: string;
   channel_data?: string;
   shared_secret?: string;
 }
 
-export type AuthorizerCallback = (
+export type ChannelAuthorizationCallback = (
+  error: Error | null,
+  authData: ChannelAuthorizationData | null
+) => void;
+
+export interface ChannelAuthorizationRequestParams {
+  socketId: string;
+  channelName: string;
+}
+
+export interface ChannelAuthorizationHandler {
+  (
+    params: ChannelAuthorizationRequestParams,
+    callback: ChannelAuthorizationCallback
+  ): void;
+}
+
+export interface UserAuthenticationData {
+  auth: string;
+  user_data: string;
+}
+
+export type UserAuthenticationCallback = (
   error: Error | null,
-  authData: AuthData
+  authData: UserAuthenticationData | null
 ) => void;
 
-export interface Authorizer {
-  authorize(socketId: string, callback: AuthorizerCallback): void;
+export interface UserAuthenticationRequestParams {
+  socketId: string;
+}
+
+export interface UserAuthenticationHandler {
+  (
+    params: UserAuthenticationRequestParams,
+    callback: UserAuthenticationCallback
+  ): void;
 }
 
-export interface AuthorizerGenerator {
-  (channel: Channel, options: AuthorizerOptions): Authorizer;
+export type AuthTransportCallback =
+  | ChannelAuthorizationCallback
+  | UserAuthenticationCallback;
+
+export interface AuthOptions<AuthHandler> {
+  transport: 'ajax' | 'jsonp';
+  endpoint: string;
+  params?: any;
+  headers?: any;
+  customHandler?: AuthHandler;
 }
 
-export interface AuthorizerOptions {
-  authTransport: 'ajax' | 'jsonp';
-  authEndpoint: string;
-  auth?: AuthOptions;
-  authorizer?: AuthorizerGenerator;
+export interface InternalAuthOptions {
+  transport: 'ajax' | 'jsonp';
+  endpoint: string;
+  params?: any;
+  headers?: any;
 }

package/src/core/auth/user_authenticator.ts

@@ -0,0 +1,51 @@
+import {
+  UserAuthenticationCallback,
+  InternalAuthOptions,
+  UserAuthenticationHandler,
+  UserAuthenticationRequestParams,
+  AuthRequestType
+} from './options';
+
+import Runtime from 'runtime';
+
+const composeChannelQuery = (
+  params: UserAuthenticationRequestParams,
+  authOptions: InternalAuthOptions
+) => {
+  var query = 'socket_id=' + encodeURIComponent(params.socketId);
+
+  for (var i in authOptions.params) {
+    query +=
+      '&' +
+      encodeURIComponent(i) +
+      '=' +
+      encodeURIComponent(authOptions.params[i]);
+  }
+
+  return query;
+};
+
+const UserAuthenticator = (
+  authOptions: InternalAuthOptions
+): UserAuthenticationHandler => {
+  if (typeof Runtime.getAuthorizers()[authOptions.transport] === 'undefined') {
+    throw `'${authOptions.transport}' is not a recognized auth transport`;
+  }
+
+  return (
+    params: UserAuthenticationRequestParams,
+    callback: UserAuthenticationCallback
+  ) => {
+    const query = composeChannelQuery(params, authOptions);
+
+    Runtime.getAuthorizers()[authOptions.transport](
+      Runtime,
+      query,
+      authOptions,
+      AuthRequestType.UserAuthentication,
+      callback
+    );
+  };
+};
+
+export default UserAuthenticator;

package/src/core/channels/channel.ts

@@ -5,7 +5,10 @@ import Pusher from '../pusher';
 import { PusherEvent } from '../connection/protocol/message-types';
 import Metadata from './metadata';
 import UrlStore from '../utils/url_store';
-import { AuthData, AuthorizerCallback } from '../auth/options';
+import {
+  ChannelAuthorizationData,
+  ChannelAuthorizationCallback
+} from '../auth/options';
 import { HTTPAuthError } from '../errors';
 
 /** Provides base public channel interface with an event emitter.
@@ -23,6 +26,7 @@ export default class Channel extends EventsDispatcher {
   subscribed: boolean;
   subscriptionPending: boolean;
   subscriptionCancelled: boolean;
+  subscriptionCount: null;
 
   constructor(name: string, pusher: Pusher) {
     super(function(event, data) {
@@ -40,7 +44,7 @@ export default class Channel extends EventsDispatcher {
    *
    * @param {Function} callback
    */
-  authorize(socketId: string, callback: AuthorizerCallback) {
+  authorize(socketId: string, callback: ChannelAuthorizationCallback) {
     return callback(null, { auth: '' });
   }
 
@@ -75,6 +79,8 @@ export default class Channel extends EventsDispatcher {
     var data = event.data;
     if (eventName === 'pusher_internal:subscription_succeeded') {
       this.handleSubscriptionSucceededEvent(event);
+    } else if (eventName === 'pusher_internal:subscription_count') {
+      this.handleSubscriptionCountEvent(event);
     } else if (eventName.indexOf('pusher_internal:') !== 0) {
       var metadata: Metadata = {};
       this.emit(eventName, data, metadata);
@@ -91,6 +97,14 @@ export default class Channel extends EventsDispatcher {
     }
   }
 
+  handleSubscriptionCountEvent(event: PusherEvent) {
+    if (event.data.subscription_count) {
+      this.subscriptionCount = event.data.subscription_count;
+    }
+
+    this.emit('pusher:subscription_count', event.data);
+  }
+
   /** Sends a subscription request. For internal use only. */
   subscribe() {
     if (this.subscribed) {
@@ -100,7 +114,7 @@ export default class Channel extends EventsDispatcher {
     this.subscriptionCancelled = false;
     this.authorize(
       this.pusher.connection.socket_id,
-      (error: Error | null, data: AuthData) => {
+      (error: Error | null, data: ChannelAuthorizationData) => {
         if (error) {
           this.subscriptionPending = false;
           // Why not bind to 'pusher:subscription_error' a level up, and log there?

package/src/core/channels/channels.ts

@@ -76,6 +76,10 @@ function createChannel(name: string, pusher: Pusher): Channel {
     return Factory.createPrivateChannel(name, pusher);
   } else if (name.indexOf('presence-') === 0) {
     return Factory.createPresenceChannel(name, pusher);
+  } else if (name.indexOf('#') === 0) {
+    throw new Errors.BadChannelName(
+      'Cannot create a channel with name "' + name + '".'
+    );
   } else {
     return Factory.createChannel(name, pusher);
   }

package/src/core/channels/encrypted_channel.ts

@@ -6,7 +6,10 @@ import { decode as encodeUTF8 } from '@stablelib/utf8';
 import { decode as decodeBase64 } from '@stablelib/base64';
 import Dispatcher from '../events/dispatcher';
 import { PusherEvent } from '../connection/protocol/message-types';
-import { AuthData, AuthorizerCallback } from '../auth/options';
+import {
+  ChannelAuthorizationData,
+  ChannelAuthorizationCallback
+} from '../auth/options';
 import * as nacl from 'tweetnacl';
 
 /** Extends private channels to provide encrypted channel interface.
@@ -28,26 +31,29 @@ export default class EncryptedChannel extends PrivateChannel {
    * @param  {String} socketId
    * @param  {Function} callback
    */
-  authorize(socketId: string, callback: AuthorizerCallback) {
-    super.authorize(socketId, (error: Error | null, authData: AuthData) => {
-      if (error) {
-        callback(error, authData);
-        return;
-      }
-      let sharedSecret = authData['shared_secret'];
-      if (!sharedSecret) {
-        callback(
-          new Error(
-            `No shared_secret key in auth payload for encrypted channel: ${this.name}`
-          ),
-          null
-        );
-        return;
+  authorize(socketId: string, callback: ChannelAuthorizationCallback) {
+    super.authorize(
+      socketId,
+      (error: Error | null, authData: ChannelAuthorizationData) => {
+        if (error) {
+          callback(error, authData);
+          return;
+        }
+        let sharedSecret = authData['shared_secret'];
+        if (!sharedSecret) {
+          callback(
+            new Error(
+              `No shared_secret key in auth payload for encrypted channel: ${this.name}`
+            ),
+            null
+          );
+          return;
+        }
+        this.key = decodeBase64(sharedSecret);
+        delete authData['shared_secret'];
+        callback(null, authData);
       }
-      this.key = decodeBase64(sharedSecret);
-      delete authData['shared_secret'];
-      callback(null, authData);
-    });
+    );
   }
 
   trigger(event: string, data: any): boolean {

package/src/core/channels/presence_channel.ts

@@ -5,7 +5,7 @@ import Pusher from '../pusher';
 import UrlStore from 'core/utils/url_store';
 import { PusherEvent } from '../connection/protocol/message-types';
 import Metadata from './metadata';
-import { AuthData } from '../auth/options';
+import { ChannelAuthorizationData } from '../auth/options';
 
 export default class PresenceChannel extends PrivateChannel {
   members: Members;
@@ -28,7 +28,7 @@ export default class PresenceChannel extends PrivateChannel {
   authorize(socketId: string, callback: Function) {
     super.authorize(socketId, (error, authData) => {
       if (!error) {
-        authData = authData as AuthData;
+        authData = authData as ChannelAuthorizationData;
         if (authData.channel_data === undefined) {
           let suffix = UrlStore.buildLogSuffix('authenticationEndpoint');
           Logger.error(
@@ -69,6 +69,9 @@ export default class PresenceChannel extends PrivateChannel {
       case 'pusher_internal:subscription_succeeded':
         this.handleSubscriptionSucceededEvent(event);
         break;
+      case 'pusher_internal:subscription_count':
+        this.handleSubscriptionCountEvent(event);
+        break;
       case 'pusher_internal:member_added':
         var addedMember = this.members.addMember(data);
         this.emit('pusher:member_added', addedMember);

package/src/core/channels/private_channel.ts

@@ -1,6 +1,6 @@
 import Factory from '../utils/factory';
 import Channel from './channel';
-import { AuthorizerCallback } from '../auth/options';
+import { ChannelAuthorizationCallback } from '../auth/options';
 
 /** Extends public channels to provide private channel interface.
  *
@@ -13,8 +13,13 @@ export default class PrivateChannel extends Channel {
    * @param  {String} socketId
    * @param  {Function} callback
    */
-  authorize(socketId: string, callback: AuthorizerCallback) {
-    var authorizer = Factory.createAuthorizer(this, this.pusher.config);
-    return authorizer.authorize(socketId, callback);
+  authorize(socketId: string, callback: ChannelAuthorizationCallback) {
+    return this.pusher.config.channelAuthorizer(
+      {
+        channelName: this.name,
+        socketId: socketId
+      },
+      callback
+    );
   }
 }