pingerchips-js 1.0.0-a

package/src/core/channels/encrypted_channel.ts

@@ -0,0 +1,149 @@
+import { decode as decodeBase64 } from '@stablelib/base64';
+import { decode as encodeUTF8 } from '@stablelib/utf8';
+import * as nacl from 'tweetnacl';
+import {
+    ChannelAuthorizationCallback,
+    ChannelAuthorizationData
+} from '../auth/options';
+import { PusherEvent } from '../connection/protocol/message-types';
+import * as Errors from '../errors';
+import Logger from '../logger';
+import Pingerchips from '../pusher';
+import PrivateChannel from './private_channel';
+
+/** Extends private channels to provide encrypted channel interface.
+ *
+ * @param {String} name
+ * @param {Pingerchips} pusher
+ */
+export default class EncryptedChannel extends PrivateChannel {
+  key: Uint8Array = null;
+  nacl: nacl;
+
+  constructor(name: string, pusher: Pingerchips, nacl: nacl) {
+    super(name, pusher);
+    this.nacl = nacl;
+  }
+
+  /** Authorizes the connection to use the channel.
+   *
+   * @param  {String} socketId
+   * @param  {Function} callback
+   */
+  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);
+      }
+    );
+  }
+
+  trigger(event: string, data: any): boolean {
+    throw new Errors.UnsupportedFeature(
+      'Client events are not currently supported for encrypted channels'
+    );
+  }
+
+  /** Handles an event. For internal use only.
+   *
+   * @param {PusherEvent} event
+   */
+  handleEvent(event: PusherEvent) {
+    var eventName = event.event;
+    var data = event.data;
+    if (
+      eventName.indexOf('pusher_internal:') === 0 ||
+      eventName.indexOf('pusher:') === 0
+    ) {
+      super.handleEvent(event);
+      return;
+    }
+    this.handleEncryptedEvent(eventName, data);
+  }
+
+  private handleEncryptedEvent(event: string, data: any): void {
+    if (!this.key) {
+      Logger.debug(
+        'Received encrypted event before key has been retrieved from the authEndpoint'
+      );
+      return;
+    }
+    if (!data.ciphertext || !data.nonce) {
+      Logger.error(
+        'Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: ' +
+          data
+      );
+      return;
+    }
+    let cipherText = decodeBase64(data.ciphertext);
+    if (cipherText.length < this.nacl.secretbox.overheadLength) {
+      Logger.error(
+        `Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${cipherText.length}`
+      );
+      return;
+    }
+    let nonce = decodeBase64(data.nonce);
+    if (nonce.length < this.nacl.secretbox.nonceLength) {
+      Logger.error(
+        `Expected encrypted event nonce length to be ${this.nacl.secretbox.nonceLength}, got: ${nonce.length}`
+      );
+      return;
+    }
+
+    let bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
+    if (bytes === null) {
+      Logger.debug(
+        'Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint...'
+      );
+      // Try a single time to retrieve a new auth key and decrypt the event with it
+      // If this fails, a new key will be requested when a new message is received
+      this.authorize(this.pusher.connection.socket_id, (error, authData) => {
+        if (error) {
+          Logger.error(
+            `Failed to make a request to the authEndpoint: ${authData}. Unable to fetch new key, so dropping encrypted event`
+          );
+          return;
+        }
+        bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
+        if (bytes === null) {
+          Logger.error(
+            `Failed to decrypt event with new key. Dropping encrypted event`
+          );
+          return;
+        }
+        this.emit(event, this.getDataToEmit(bytes));
+        return;
+      });
+      return;
+    }
+    this.emit(event, this.getDataToEmit(bytes));
+  }
+
+  // Try and parse the decrypted bytes as JSON. If we can't parse it, just
+  // return the utf-8 string
+  getDataToEmit(bytes: Uint8Array): string {
+    let raw = encodeUTF8(bytes);
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+}

package/src/core/channels/members.ts

@@ -0,0 +1,80 @@
+import * as Collections from '../utils/collections';
+
+/** Represents a collection of members of a presence channel. */
+export default class Members {
+  members: any;
+  count: number;
+  myID: any;
+  me: any;
+
+  constructor() {
+    this.reset();
+  }
+
+  /** Returns member's info for given id.
+   *
+   * Resulting object containts two fields - id and info.
+   *
+   * @param {Number} id
+   * @return {Object} member's info or null
+   */
+  get(id: string): any {
+    if (Object.prototype.hasOwnProperty.call(this.members, id)) {
+      return {
+        id: id,
+        info: this.members[id]
+      };
+    } else {
+      return null;
+    }
+  }
+
+  /** Calls back for each member in unspecified order.
+   *
+   * @param  {Function} callback
+   */
+  each(callback: Function) {
+    Collections.objectApply(this.members, (member, id) => {
+      callback(this.get(id));
+    });
+  }
+
+  /** Updates the id for connected member. For internal use only. */
+  setMyID(id: string) {
+    this.myID = id;
+  }
+
+  /** Handles subscription data. For internal use only. */
+  onSubscription(subscriptionData: any) {
+    this.members = subscriptionData.presence.hash;
+    this.count = subscriptionData.presence.count;
+    this.me = this.get(this.myID);
+  }
+
+  /** Adds a new member to the collection. For internal use only. */
+  addMember(memberData: any) {
+    if (this.get(memberData.user_id) === null) {
+      this.count++;
+    }
+    this.members[memberData.user_id] = memberData.user_info;
+    return this.get(memberData.user_id);
+  }
+
+  /** Adds a member from the collection. For internal use only. */
+  removeMember(memberData: any) {
+    var member = this.get(memberData.user_id);
+    if (member) {
+      delete this.members[memberData.user_id];
+      this.count--;
+    }
+    return member;
+  }
+
+  /** Resets the collection to the initial state. For internal use only. */
+  reset() {
+    this.members = {};
+    this.count = 0;
+    this.myID = null;
+    this.me = null;
+  }
+}

package/src/core/channels/metadata.ts

@@ -0,0 +1,5 @@
+interface Metadata {
+  user_id?: string;
+}
+
+export default Metadata;

package/src/core/channels/presence_channel.ts

@@ -0,0 +1,113 @@
+import UrlStore from 'core/utils/url_store';
+import { ChannelAuthorizationData } from '../auth/options';
+import { PusherEvent } from '../connection/protocol/message-types';
+import Logger from '../logger';
+import Pingerchips from '../pusher';
+import Members from './members';
+import Metadata from './metadata';
+import PrivateChannel from './private_channel';
+
+export default class PresenceChannel extends PrivateChannel {
+  members: Members;
+
+  /** Adds presence channel functionality to private channels.
+   *
+   * @param {String} name
+   * @param {Pingerchips} pusher
+   */
+  constructor(name: string, pusher: Pingerchips) {
+    super(name, pusher);
+    this.members = new Members();
+  }
+
+  /** Authorizes the connection as a member of the channel.
+   *
+   * @param  {String} socketId
+   * @param  {Function} callback
+   */
+  authorize(socketId: string, callback: Function) {
+    super.authorize(socketId, async (error, authData) => {
+      if (!error) {
+        authData = authData as ChannelAuthorizationData;
+        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;
+          }
+        }
+      }
+      callback(error, authData);
+    });
+  }
+
+  /** Handles presence and subscription events. For internal use only.
+   *
+   * @param {PusherEvent} event
+   */
+  handleEvent(event: PusherEvent) {
+    var eventName = event.event;
+    if (eventName.indexOf('pusher_internal:') === 0) {
+      this.handleInternalEvent(event);
+    } else {
+      var data = event.data;
+      var metadata: Metadata = {};
+      if (event.user_id) {
+        metadata.user_id = event.user_id;
+      }
+      this.emit(eventName, data, metadata);
+    }
+  }
+  handleInternalEvent(event: PusherEvent) {
+    var eventName = event.event;
+    var data = event.data;
+    switch (eventName) {
+      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);
+        break;
+      case 'pusher_internal:member_removed':
+        var removedMember = this.members.removeMember(data);
+        if (removedMember) {
+          this.emit('pusher:member_removed', removedMember);
+        }
+        break;
+    }
+  }
+
+  handleSubscriptionSucceededEvent(event: PusherEvent) {
+    this.subscriptionPending = false;
+    this.subscribed = true;
+    if (this.subscriptionCancelled) {
+      this.pusher.unsubscribe(this.name);
+    } else {
+      this.members.onSubscription(event.data);
+      this.emit('pusher:subscription_succeeded', this.members);
+    }
+  }
+
+  /** Resets the channel state, including members map. For internal use only. */
+  disconnect() {
+    this.members.reset();
+    super.disconnect();
+  }
+}

package/src/core/channels/private_channel.ts

@@ -0,0 +1,25 @@
+import Factory from '../utils/factory';
+import Channel from './channel';
+import { ChannelAuthorizationCallback } from '../auth/options';
+
+/** Extends public channels to provide private channel interface.
+ *
+ * @param {String} name
+ * @param {Pusher} pusher
+ */
+export default class PrivateChannel extends Channel {
+  /** Authorizes the connection to use the channel.
+   *
+   * @param  {String} socketId
+   * @param  {Function} callback
+   */
+  authorize(socketId: string, callback: ChannelAuthorizationCallback) {
+    return this.pusher.config.channelAuthorizer(
+      {
+        channelName: this.name,
+        socketId: socketId
+      },
+      callback
+    );
+  }
+}

package/src/core/config.ts

@@ -0,0 +1,189 @@
+import { Options } from './options';
+import Defaults from './defaults';
+import {
+  ChannelAuthorizationHandler,
+  UserAuthenticationHandler,
+  ChannelAuthorizationOptions
+} from './auth/options';
+import UserAuthenticator from './auth/user_authenticator';
+import ChannelAuthorizer from './auth/channel_authorizer';
+import { ChannelAuthorizerProxy } from './auth/deprecated_channel_authorizer';
+import Runtime from 'runtime';
+import * as nacl from 'tweetnacl';
+
+export type AuthTransport = 'ajax' | 'jsonp';
+export type Transport =
+  | 'ws'
+  | 'wss'
+  | 'xhr_streaming'
+  | 'xhr_polling'
+  | 'sockjs';
+
+export interface Config {
+  // these are all 'required' config parameters, it's not necessary for the user
+  // to set them, but they have configured defaults.
+  activityTimeout: number;
+  enableStats: boolean;
+  httpHost: string;
+  httpPath: string;
+  httpPort: number;
+  httpsPort: number;
+  pongTimeout: number;
+  statsHost: string;
+  unavailableTimeout: number;
+  useTLS: boolean;
+  wsHost: string;
+  wsPath: string;
+  wsPort: number;
+  wssPort: number;
+  userAuthenticator: UserAuthenticationHandler;
+  channelAuthorizer: ChannelAuthorizationHandler;
+
+  // these are all optional parameters or overrrides. The customer can set these
+  // but it's not strictly necessary
+  forceTLS?: boolean;
+  cluster?: string;
+  disabledTransports?: Transport[];
+  enabledTransports?: Transport[];
+  ignoreNullOrigin?: boolean;
+  nacl?: nacl;
+  timelineParams?: any;
+}
+
+// getConfig mainly sets the defaults for the options that are not provided
+export function getConfig(opts: Options, pusher): Config {
+  let config: Config = {
+    activityTimeout: opts.activityTimeout || Defaults.activityTimeout,
+    cluster: opts.cluster,
+    httpPath: opts.httpPath || Defaults.httpPath,
+    httpPort: opts.httpPort || Defaults.httpPort,
+    httpsPort: opts.httpsPort || Defaults.httpsPort,
+    pongTimeout: opts.pongTimeout || Defaults.pongTimeout,
+    statsHost: opts.statsHost || Defaults.stats_host,
+    unavailableTimeout: opts.unavailableTimeout || Defaults.unavailableTimeout,
+    wsPath: opts.wsPath || Defaults.wsPath,
+    wsPort: opts.wsPort || Defaults.wsPort,
+    wssPort: opts.wssPort || Defaults.wssPort,
+
+    enableStats: getEnableStatsConfig(opts),
+    httpHost: getHttpHost(opts),
+    useTLS: shouldUseTLS(opts),
+    wsHost: getWebsocketHost(opts),
+
+    userAuthenticator: buildUserAuthenticator(opts),
+    channelAuthorizer: buildChannelAuthorizer(opts, pusher)
+  };
+
+  if ('disabledTransports' in opts)
+    config.disabledTransports = opts.disabledTransports;
+  if ('enabledTransports' in opts)
+    config.enabledTransports = opts.enabledTransports;
+  if ('ignoreNullOrigin' in opts)
+    config.ignoreNullOrigin = opts.ignoreNullOrigin;
+  if ('timelineParams' in opts) config.timelineParams = opts.timelineParams;
+  if ('nacl' in opts) {
+    config.nacl = opts.nacl;
+  }
+
+  return config;
+}
+
+function getHttpHost(opts: Options): string {
+  if (opts.httpHost) {
+    return opts.httpHost;
+  }
+  if (opts.cluster) {
+    return `sockjs-${opts.cluster}.pusher.com`;
+  }
+  return Defaults.httpHost;
+}
+
+function getWebsocketHost(opts: Options): string {
+  if (opts.wsHost) {
+    return opts.wsHost;
+  }
+  return getWebsocketHostFromCluster(opts.cluster);
+}
+
+function getWebsocketHostFromCluster(cluster: string): string {
+  return `ws-${cluster}.pusher.com`;
+}
+
+function shouldUseTLS(opts: Options): boolean {
+  if (Runtime.getProtocol() === 'https:') {
+    return true;
+  } else if (opts.forceTLS === false) {
+    return false;
+  }
+  return true;
+}
+
+// if enableStats is set take the value
+// if disableStats is set take the inverse
+// otherwise default to false
+function getEnableStatsConfig(opts: Options): boolean {
+  if ('enableStats' in opts) {
+    return opts.enableStats;
+  }
+  if ('disableStats' in opts) {
+    return !opts.disableStats;
+  }
+  return false;
+}
+
+function buildUserAuthenticator(opts: Options): UserAuthenticationHandler {
+  const userAuthentication = {
+    ...Defaults.userAuthentication,
+    ...opts.userAuthentication
+  };
+  if (
+    'customHandler' in userAuthentication &&
+    userAuthentication['customHandler'] != null
+  ) {
+    return userAuthentication['customHandler'];
+  }
+
+  return UserAuthenticator(userAuthentication);
+}
+
+function buildChannelAuth(opts: Options, pusher): ChannelAuthorizationOptions {
+  let channelAuthorization: ChannelAuthorizationOptions;
+  if ('channelAuthorization' in opts) {
+    channelAuthorization = {
+      ...Defaults.channelAuthorization,
+      ...opts.channelAuthorization
+    };
+  } else {
+    channelAuthorization = {
+      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
+      );
+  }
+  return channelAuthorization;
+}
+
+function buildChannelAuthorizer(
+  opts: Options,
+  pusher
+): ChannelAuthorizationHandler {
+  const channelAuthorization = buildChannelAuth(opts, pusher);
+  if (
+    'customHandler' in channelAuthorization &&
+    channelAuthorization['customHandler'] != null
+  ) {
+    return channelAuthorization['customHandler'];
+  }
+
+  return ChannelAuthorizer(channelAuthorization);
+}

package/src/core/connection/callbacks.ts

@@ -0,0 +1,21 @@
+import HandshakePayload from './handshake/handshake_payload';
+import Action from './protocol/action';
+
+export interface ErrorCallbacks {
+  tls_only: (result: Action | HandshakePayload) => void;
+  refused: (result: Action | HandshakePayload) => void;
+  backoff: (result: Action | HandshakePayload) => void;
+  retry: (result: Action | HandshakePayload) => void;
+}
+
+export interface HandshakeCallbacks {
+  connected: (handshake: HandshakePayload) => void;
+}
+
+export interface ConnectionCallbacks {
+  message: (message: any) => void;
+  ping: () => void;
+  activity: () => void;
+  error: (error: any) => void;
+  closed: () => void;
+}