@cendarsoss/pusher-js 8.4.11

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;
+}

package/src/core/connection/connection.ts

@@ -0,0 +1,160 @@
+import * as Collections from '../utils/collections';
+import { default as EventsDispatcher } from '../events/dispatcher';
+import Protocol from './protocol/protocol';
+import { PusherEvent } from './protocol/message-types';
+import Logger from '../logger';
+import TransportConnection from '../transports/transport_connection';
+import Socket from '../socket';
+/**
+ * Provides Pusher protocol interface for transports.
+ *
+ * Emits following events:
+ * - message - on received messages
+ * - ping - on ping requests
+ * - pong - on pong responses
+ * - error - when the transport emits an error
+ * - closed - after closing the transport
+ *
+ * It also emits more events when connection closes with a code.
+ * See Protocol.getCloseAction to get more details.
+ *
+ * @param {Number} id
+ * @param {AbstractTransport} transport
+ */
+export default class Connection extends EventsDispatcher implements Socket {
+  id: string;
+  transport: TransportConnection;
+  activityTimeout: number;
+
+  constructor(id: string, transport: TransportConnection) {
+    super();
+    this.id = id;
+    this.transport = transport;
+    this.activityTimeout = transport.activityTimeout;
+    this.bindListeners();
+  }
+
+  /** Returns whether used transport handles activity checks by itself
+   *
+   * @returns {Boolean} true if activity checks are handled by the transport
+   */
+  handlesActivityChecks() {
+    return this.transport.handlesActivityChecks();
+  }
+
+  /** Sends raw data.
+   *
+   * @param {String} data
+   */
+  send(data: any): boolean {
+    return this.transport.send(data);
+  }
+
+  /** Sends an event.
+   *
+   * @param {String} name
+   * @param {String} data
+   * @param {String} [channel]
+   * @returns {Boolean} whether message was sent or not
+   */
+  send_event(name: string, data: any, channel?: string): boolean {
+    var event: PusherEvent = { event: name, data: data };
+    if (channel) {
+      event.channel = channel;
+    }
+    Logger.debug('Event sent', event);
+    return this.send(Protocol.encodeMessage(event));
+  }
+
+  /** Sends a ping message to the server.
+   *
+   * Basing on the underlying transport, it might send either transport's
+   * protocol-specific ping or pusher:ping event.
+   */
+  ping() {
+    if (this.transport.supportsPing()) {
+      this.transport.ping();
+    } else {
+      this.send_event('pusher:ping', {});
+    }
+  }
+
+  /** Closes the connection. */
+  close() {
+    this.transport.close();
+  }
+
+  private bindListeners() {
+    var listeners = {
+      message: (messageEvent: MessageEvent) => {
+        var pusherEvent;
+        try {
+          pusherEvent = Protocol.decodeMessage(messageEvent);
+        } catch (e) {
+          this.emit('error', {
+            type: 'MessageParseError',
+            error: e,
+            data: messageEvent.data,
+          });
+        }
+
+        if (pusherEvent !== undefined) {
+          Logger.debug('Event recd', pusherEvent);
+
+          switch (pusherEvent.event) {
+            case 'pusher:error':
+              this.emit('error', {
+                type: 'PusherError',
+                data: pusherEvent.data,
+              });
+              break;
+            case 'pusher:ping':
+              this.emit('ping');
+              break;
+            case 'pusher:pong':
+              this.emit('pong');
+              break;
+          }
+          this.emit('message', pusherEvent);
+        }
+      },
+      activity: () => {
+        this.emit('activity');
+      },
+      error: (error) => {
+        this.emit('error', error);
+      },
+      closed: (closeEvent) => {
+        unbindListeners();
+
+        if (closeEvent && closeEvent.code) {
+          this.handleCloseEvent(closeEvent);
+        }
+
+        this.transport = null;
+        this.emit('closed');
+      },
+    };
+
+    var unbindListeners = () => {
+      Collections.objectApply(listeners, (listener, event) => {
+        this.transport.unbind(event, listener);
+      });
+    };
+
+    Collections.objectApply(listeners, (listener, event) => {
+      this.transport.bind(event, listener);
+    });
+  }
+
+  private handleCloseEvent(closeEvent: any) {
+    var action = Protocol.getCloseAction(closeEvent);
+    var error = Protocol.getCloseError(closeEvent);
+    if (error) {
+      this.emit('error', error);
+    }
+    if (action) {
+      this.emit(action, { action: action, error: error });
+    }
+  }
+}