pingerchips-js 1.0.0 → 2.0.0

package/src/core/channels/encrypted_channel.ts

@@ -1,149 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

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

package/src/core/channels/presence_channel.ts

@@ -1,113 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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;
-}