pingerchips-js 1.0.1-a → 2.0.0

package/src/core/auth/channel_authorizer.ts

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

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

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

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

@@ -1,163 +0,0 @@
-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 '../pingerchips';
-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

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

package/src/core/channels/channels.ts

@@ -1,85 +0,0 @@
-import * as Errors from '../errors';
-import Pingerchips from '../pingerchips';
-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);
-  }
-}