pingerchips-js 1.0.0-a

package/src/core/auth/channel_authorizer.ts

@@ -0,0 +1,64 @@
+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 key in authOptions.params) {
+    query +=
+      '&' +
+      encodeURIComponent(key) +
+      '=' +
+      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;
+};
+
+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

@@ -0,0 +1,78 @@
+export enum AuthRequestType {
+  UserAuthentication = 'user-authentication',
+  ChannelAuthorization = 'channel-authorization'
+}
+
+export interface ChannelAuthorizationData {
+  auth: string;
+  channel_data?: string;
+  shared_secret?: string;
+}
+
+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: UserAuthenticationData | null
+) => void;
+
+export interface UserAuthenticationRequestParams {
+  socketId: string;
+}
+
+export interface UserAuthenticationHandler {
+  (
+    params: UserAuthenticationRequestParams,
+    callback: UserAuthenticationCallback
+  ): void;
+}
+
+export type AuthTransportCallback =
+  | ChannelAuthorizationCallback
+  | UserAuthenticationCallback;
+
+export interface AuthOptionsT<AuthHandler> {
+  transport: 'ajax' | 'jsonp';
+  endpoint: string;
+  params?: any;
+  headers?: any;
+  paramsProvider?: () => any;
+  headersProvider?: () => any;
+  customHandler?: 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/auth/user_authenticator.ts

@@ -0,0 +1,62 @@
+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 key in authOptions.params) {
+    query +=
+      '&' +
+      encodeURIComponent(key) +
+      '=' +
+      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;
+};
+
+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/base64.ts

@@ -0,0 +1,49 @@
+export default function encode(s: any): string {
+  return btoa(utob(s));
+}
+
+var fromCharCode = String.fromCharCode;
+
+var b64chars =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+var b64tab = {};
+
+for (var i = 0, l = b64chars.length; i < l; i++) {
+  b64tab[b64chars.charAt(i)] = i;
+}
+
+var cb_utob = function(c) {
+  var cc = c.charCodeAt(0);
+  return cc < 0x80
+    ? c
+    : cc < 0x800
+    ? fromCharCode(0xc0 | (cc >>> 6)) + fromCharCode(0x80 | (cc & 0x3f))
+    : fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) +
+      fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +
+      fromCharCode(0x80 | (cc & 0x3f));
+};
+
+var utob = function(u) {
+  return u.replace(/[^\x00-\x7F]/g, cb_utob);
+};
+
+var cb_encode = function(ccc) {
+  var padlen = [0, 2, 1][ccc.length % 3];
+  var ord =
+    (ccc.charCodeAt(0) << 16) |
+    ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8) |
+    (ccc.length > 2 ? ccc.charCodeAt(2) : 0);
+  var chars = [
+    b64chars.charAt(ord >>> 18),
+    b64chars.charAt((ord >>> 12) & 63),
+    padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
+    padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
+  ];
+  return chars.join('');
+};
+
+var btoa =
+  global.btoa ||
+  function(b) {
+    return b.replace(/[\s\S]{1,3}/g, cb_encode);
+  };

package/src/core/channels/channel.ts

@@ -0,0 +1,163 @@
+import {
+    ChannelAuthorizationCallback,
+    ChannelAuthorizationData
+} from '../auth/options';
+import { PusherEvent } from '../connection/protocol/message-types';
+import * as Errors from '../errors';
+import { HTTPAuthError } from '../errors';
+import { default as EventsDispatcher } from '../events/dispatcher';
+import Logger from '../logger';
+import Pingerchips from '../pusher';
+import UrlStore from '../utils/url_store';
+import Metadata from './metadata';
+
+/** Provides base public channel interface with an event emitter.
+ *
+ * Emits:
+ * - pusher:subscription_succeeded - after subscribing successfully
+ * - other non-internal events
+ *
+ * @param {String} name
+ * @param {Pingerchips} pusher
+ */
+export default class Channel extends EventsDispatcher {
+  name: string;
+  pusher: Pingerchips;
+  subscribed: boolean;
+  subscriptionPending: boolean;
+  subscriptionCancelled: boolean;
+  subscriptionCount: null;
+
+  constructor(name: string, pusher: Pingerchips) {
+    super(function(event, data) {
+      Logger.debug('No callbacks on ' + name + ' for ' + event);
+    });
+
+    this.name = name;
+    this.pusher = pusher;
+    this.subscribed = false;
+    this.subscriptionPending = false;
+    this.subscriptionCancelled = false;
+  }
+
+  /** Skips authorization, since public channels don't require it.
+   *
+   * @param {Function} callback
+   */
+  authorize(socketId: string, callback: ChannelAuthorizationCallback) {
+    return callback(null, { auth: '' });
+  }
+
+  /** Triggers an event */
+  trigger(event: string, data: any) {
+    if (event.indexOf('client-') !== 0) {
+      throw new Errors.BadEventName(
+        "Event '" + event + "' does not start with 'client-'"
+      );
+    }
+    if (!this.subscribed) {
+      var suffix = UrlStore.buildLogSuffix('triggeringClientEvents');
+      Logger.warn(
+        `Client event triggered before channel 'subscription_succeeded' event . ${suffix}`
+      );
+    }
+    return this.pusher.send_event(event, data, this.name);
+  }
+
+  /** Signals disconnection to the channel. For internal use only. */
+  disconnect() {
+    this.subscribed = false;
+    this.subscriptionPending = false;
+  }
+
+  /** Handles a PusherEvent. For internal use only.
+   *
+   * @param {PusherEvent} event
+   */
+  handleEvent(event: PusherEvent) {
+    var eventName = event.event;
+    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);
+    }
+  }
+
+  handleSubscriptionSucceededEvent(event: PusherEvent) {
+    this.subscriptionPending = false;
+    this.subscribed = true;
+    if (this.subscriptionCancelled) {
+      this.pusher.unsubscribe(this.name);
+    } else {
+      this.emit('pusher:subscription_succeeded', event.data);
+    }
+  }
+
+  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) {
+      return;
+    }
+    this.subscriptionPending = true;
+    this.subscriptionCancelled = false;
+    this.authorize(
+      this.pusher.connection.socket_id,
+      (error: Error | null, data: ChannelAuthorizationData) => {
+        if (error) {
+          this.subscriptionPending = false;
+          // Why not bind to 'pusher:subscription_error' a level up, and log there?
+          // Binding to this event would cause the warning about no callbacks being
+          // bound (see constructor) to be suppressed, that's not what we want.
+          Logger.error(error.toString());
+          this.emit(
+            'pusher:subscription_error',
+            Object.assign(
+              {},
+              {
+                type: 'AuthError',
+                error: error.message
+              },
+              error instanceof HTTPAuthError ? { status: error.status } : {}
+            )
+          );
+        } else {
+          this.pusher.send_event('pusher:subscribe', {
+            auth: data.auth,
+            channel_data: data.channel_data,
+            channel: this.name
+          });
+        }
+      }
+    );
+  }
+
+  /** Sends an unsubscription request. For internal use only. */
+  unsubscribe() {
+    this.subscribed = false;
+    this.pusher.send_event('pusher:unsubscribe', {
+      channel: this.name
+    });
+  }
+
+  /** Cancels an in progress subscription. For internal use only. */
+  cancelSubscription() {
+    this.subscriptionCancelled = true;
+  }
+
+  /** Reinstates an in progress subscripiton. For internal use only. */
+  reinstateSubscription() {
+    this.subscriptionCancelled = false;
+  }
+}

package/src/core/channels/channel_table.ts

@@ -0,0 +1,7 @@
+import Channel from './channel';
+
+interface ChannelTable {
+  [index: string]: Channel;
+}
+
+export default ChannelTable;

package/src/core/channels/channels.ts

@@ -0,0 +1,85 @@
+import * as Errors from '../errors';
+import Pingerchips from '../pusher';
+import * as Collections from '../utils/collections';
+import Factory from '../utils/factory';
+import urlStore from '../utils/url_store';
+import Channel from './channel';
+import ChannelTable from './channel_table';
+
+/** Handles a channel map. */
+export default class Channels {
+  channels: ChannelTable;
+
+  constructor() {
+    this.channels = {};
+  }
+
+  /** Creates or retrieves an existing channel by its name.
+   *
+   * @param {String} name
+   * @param {Pingerchips} pusher
+   * @return {Channel}
+   */
+  add(name: string, pusher: Pingerchips) {
+    if (!this.channels[name]) {
+      this.channels[name] = createChannel(name, pusher);
+    }
+    return this.channels[name];
+  }
+
+  /** Returns a list of all channels
+   *
+   * @return {Array}
+   */
+  all(): Channel[] {
+    return Collections.values(this.channels);
+  }
+
+  /** Finds a channel by its name.
+   *
+   * @param {String} name
+   * @return {Channel} channel or null if it doesn't exist
+   */
+  find(name: string) {
+    return this.channels[name];
+  }
+
+  /** Removes a channel from the map.
+   *
+   * @param {String} name
+   */
+  remove(name: string) {
+    var channel = this.channels[name];
+    delete this.channels[name];
+    return channel;
+  }
+
+  /** Proxies disconnection signal to all channels. */
+  disconnect() {
+    Collections.objectApply(this.channels, function(channel) {
+      channel.disconnect();
+    });
+  }
+}
+
+function createChannel(name: string, pusher: Pingerchips): Channel {
+  if (name.indexOf('private-encrypted-') === 0) {
+    if (pusher.config.nacl) {
+      return Factory.createEncryptedChannel(name, pusher, pusher.config.nacl);
+    }
+    let errMsg =
+      'Tried to subscribe to a private-encrypted- channel but no nacl implementation available';
+    let suffix = urlStore.buildLogSuffix('encryptedChannelSupport');
+    throw new Errors.UnsupportedFeature(`${errMsg}. ${suffix}`);
+  } else if (name.indexOf('private-') === 0) {
+    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);
+  }
+}