pingerchips-js 1.0.0-a

package/src/runtimes/interface.ts

@@ -0,0 +1,59 @@
+import { AuthTransports } from '../core/auth/auth_transports';
+import { Config } from '../core/config';
+import Ajax from '../core/http/ajax';
+import HTTPFactory from '../core/http/http_factory';
+import HTTPRequest from '../core/http/http_request';
+import Pingerchips from '../core/pusher';
+import Reachability from '../core/reachability';
+import Socket from '../core/socket';
+import Strategy from '../core/strategies/strategy';
+import StrategyOptions from '../core/strategies/strategy_options';
+import TimelineTransport from '../core/timeline/timeline_transport';
+import TransportsTable from '../core/transports/transports_table';
+import JSONPRequest from './web/dom/jsonp_request';
+
+/*
+This interface is implemented in web/runtime, node/runtime, react-native/runtime
+and worker/runtime. Its job is to be the only point of contact to platform-specific
+code for the core library. When the core library imports "runtime", Webpack will
+look for src/runtimes/<platform>/runtime.ts. This is how PusherJS keeps
+core and platform-specific code separate.
+*/
+interface Runtime {
+  setup(PusherClass: {
+    new (key: string, options: any): Pingerchips;
+    ready(): void;
+  }): void;
+  getProtocol(): string;
+  getAuthorizers(): AuthTransports;
+  getLocalStorage(): any;
+  TimelineTransport: TimelineTransport;
+  createXHR(): Ajax;
+  createWebSocket(url: string): Socket;
+  getNetwork(): Reachability;
+  getDefaultStrategy(
+    config: Config,
+    options: StrategyOptions,
+    defineTransport: Function
+  ): Strategy;
+  Transports: TransportsTable;
+  getWebSocketAPI(): new (url: string) => Socket;
+  getXHRAPI(): new () => Ajax;
+  addUnloadListener(listener: Function): void;
+  removeUnloadListener(listener: Function): void;
+  transportConnectionInitializer: Function;
+  HTTPFactory: HTTPFactory;
+  isXHRSupported(): boolean;
+  createSocketRequest(method: string, url: string): HTTPRequest;
+  randomInt(max: number): number;
+
+  // these methods/types are only implemented in the web Runtime, so they're
+  // optional but must be included in the interface
+  getDocument?(): Document;
+  createScriptRequest?(url: string): any;
+  createJSONPRequest?(url: string, data: any): JSONPRequest;
+  ScriptReceivers?: any;
+  isXDRSupported?(useTLS?: boolean): boolean;
+}
+
+export default Runtime;

package/src/runtimes/isomorphic/auth/xhr_auth.ts

@@ -0,0 +1,90 @@
+import TimelineSender from 'core/timeline/timeline_sender';
+import * as Collections from 'core/utils/collections';
+import Util from 'core/util';
+import Runtime from 'runtime';
+import { AuthTransport } from 'core/auth/auth_transports';
+import AbstractRuntime from 'runtimes/interface';
+import UrlStore from 'core/utils/url_store';
+import {
+  AuthRequestType,
+  AuthTransportCallback,
+  InternalAuthOptions
+} from 'core/auth/options';
+import { HTTPAuthError } from 'core/errors';
+
+const ajax: AuthTransport = function(
+  context: AbstractRuntime,
+  query: string,
+  authOptions: InternalAuthOptions,
+  authRequestType: AuthRequestType,
+  callback: AuthTransportCallback
+) {
+  const xhr = Runtime.createXHR();
+  xhr.open('POST', authOptions.endpoint, true);
+
+  // add request headers
+  xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+  for (var headerName in authOptions.headers) {
+    xhr.setRequestHeader(headerName, authOptions.headers[headerName]);
+  }
+  if (authOptions.headersProvider != null) {
+    let dynamicHeaders = authOptions.headersProvider();
+    for (var headerName in dynamicHeaders) {
+      xhr.setRequestHeader(headerName, dynamicHeaders[headerName]);
+    }
+  }
+
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState === 4) {
+      if (xhr.status === 200) {
+        let data;
+        let parsed = false;
+
+        try {
+          data = JSON.parse(xhr.responseText);
+          parsed = true;
+        } catch (e) {
+          callback(
+            new HTTPAuthError(
+              200,
+              `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${
+                xhr.responseText
+              }`
+            ),
+            null
+          );
+        }
+
+        if (parsed) {
+          // prevents double execution.
+          callback(null, data);
+        }
+      } else {
+        let suffix = '';
+        switch (authRequestType) {
+          case AuthRequestType.UserAuthentication:
+            suffix = UrlStore.buildLogSuffix('authenticationEndpoint');
+            break;
+          case AuthRequestType.ChannelAuthorization:
+            suffix = `Clients must be authorized to join private or presence channels. ${UrlStore.buildLogSuffix(
+              'authorizationEndpoint'
+            )}`;
+            break;
+        }
+        callback(
+          new HTTPAuthError(
+            xhr.status,
+            `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - ` +
+              `received status: ${xhr.status} from ${authOptions.endpoint}. ${suffix}`
+          ),
+          null
+        );
+      }
+    }
+  };
+
+  xhr.send(query);
+  return xhr;
+};
+
+export default ajax;

package/src/runtimes/isomorphic/default_strategy.ts

@@ -0,0 +1,155 @@
+import * as Collections from 'core/utils/collections';
+import TransportManager from 'core/transports/transport_manager';
+import Strategy from 'core/strategies/strategy';
+import SequentialStrategy from 'core/strategies/sequential_strategy';
+import BestConnectedEverStrategy from 'core/strategies/best_connected_ever_strategy';
+import WebSocketPrioritizedCachedStrategy, {
+  TransportStrategyDictionary
+} from 'core/strategies/websocket_prioritized_cached_strategy';
+import DelayedStrategy from 'core/strategies/delayed_strategy';
+import IfStrategy from 'core/strategies/if_strategy';
+import FirstConnectedStrategy from 'core/strategies/first_connected_strategy';
+import { Config } from 'core/config';
+import StrategyOptions from 'core/strategies/strategy_options';
+
+function testSupportsStrategy(strategy: Strategy) {
+  return function() {
+    return strategy.isSupported();
+  };
+}
+
+var getDefaultStrategy = function(
+  config: Config,
+  baseOptions: StrategyOptions,
+  defineTransport: Function
+): Strategy {
+  var definedTransports = <TransportStrategyDictionary>{};
+
+  function defineTransportStrategy(
+    name: string,
+    type: string,
+    priority: number,
+    options: StrategyOptions,
+    manager?: TransportManager
+  ) {
+    var transport = defineTransport(
+      config,
+      name,
+      type,
+      priority,
+      options,
+      manager
+    );
+
+    definedTransports[name] = transport;
+
+    return transport;
+  }
+
+  var ws_options: StrategyOptions = Object.assign({}, baseOptions, {
+    hostNonTLS: config.wsHost + ':' + config.wsPort,
+    hostTLS: config.wsHost + ':' + config.wssPort,
+    httpPath: config.wsPath
+  });
+  var wss_options: StrategyOptions = Collections.extend({}, ws_options, {
+    useTLS: true
+  });
+  var http_options: StrategyOptions = Object.assign({}, baseOptions, {
+    hostNonTLS: config.httpHost + ':' + config.httpPort,
+    hostTLS: config.httpHost + ':' + config.httpsPort,
+    httpPath: config.httpPath
+  });
+  var timeouts = {
+    loop: true,
+    timeout: 15000,
+    timeoutLimit: 60000
+  };
+
+  var ws_manager = new TransportManager({
+    minPingDelay: 10000,
+    maxPingDelay: config.activityTimeout
+  });
+  var streaming_manager = new TransportManager({
+    lives: 2,
+    minPingDelay: 10000,
+    maxPingDelay: config.activityTimeout
+  });
+
+  var ws_transport = defineTransportStrategy(
+    'ws',
+    'ws',
+    3,
+    ws_options,
+    ws_manager
+  );
+  var wss_transport = defineTransportStrategy(
+    'wss',
+    'ws',
+    3,
+    wss_options,
+    ws_manager
+  );
+  var xhr_streaming_transport = defineTransportStrategy(
+    'xhr_streaming',
+    'xhr_streaming',
+    1,
+    http_options,
+    streaming_manager
+  );
+  var xhr_polling_transport = defineTransportStrategy(
+    'xhr_polling',
+    'xhr_polling',
+    1,
+    http_options
+  );
+
+  var ws_loop = new SequentialStrategy([ws_transport], timeouts);
+  var wss_loop = new SequentialStrategy([wss_transport], timeouts);
+  var streaming_loop = new SequentialStrategy(
+    [xhr_streaming_transport],
+    timeouts
+  );
+  var polling_loop = new SequentialStrategy([xhr_polling_transport], timeouts);
+
+  var http_loop = new SequentialStrategy(
+    [
+      new IfStrategy(
+        testSupportsStrategy(streaming_loop),
+        new BestConnectedEverStrategy([
+          streaming_loop,
+          new DelayedStrategy(polling_loop, { delay: 4000 })
+        ]),
+        polling_loop
+      )
+    ],
+    timeouts
+  );
+
+  var wsStrategy;
+  if (baseOptions.useTLS) {
+    wsStrategy = new BestConnectedEverStrategy([
+      ws_loop,
+      new DelayedStrategy(http_loop, { delay: 2000 })
+    ]);
+  } else {
+    wsStrategy = new BestConnectedEverStrategy([
+      ws_loop,
+      new DelayedStrategy(wss_loop, { delay: 2000 }),
+      new DelayedStrategy(http_loop, { delay: 5000 })
+    ]);
+  }
+
+  return new WebSocketPrioritizedCachedStrategy(
+    new FirstConnectedStrategy(
+      new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop)
+    ),
+    definedTransports,
+    {
+      ttl: 1800000,
+      timeline: baseOptions.timeline,
+      useTLS: baseOptions.useTLS
+    }
+  );
+};
+
+export default getDefaultStrategy;

package/src/runtimes/isomorphic/http/http.ts

@@ -0,0 +1,32 @@
+import HTTPRequest from 'core/http/http_request';
+import HTTPSocket from 'core/http/http_socket';
+import SocketHooks from 'core/http/socket_hooks';
+import RequestHooks from 'core/http/request_hooks';
+import streamingHooks from 'core/http/http_streaming_socket';
+import pollingHooks from 'core/http/http_polling_socket';
+import xhrHooks from './http_xhr_request';
+import HTTPFactory from 'core/http/http_factory';
+
+var HTTP: HTTPFactory = {
+  createStreamingSocket(url: string): HTTPSocket {
+    return this.createSocket(streamingHooks, url);
+  },
+
+  createPollingSocket(url: string): HTTPSocket {
+    return this.createSocket(pollingHooks, url);
+  },
+
+  createSocket(hooks: SocketHooks, url: string): HTTPSocket {
+    return new HTTPSocket(hooks, url);
+  },
+
+  createXHR(method: string, url: string): HTTPRequest {
+    return this.createRequest(xhrHooks, method, url);
+  },
+
+  createRequest(hooks: RequestHooks, method: string, url: string): HTTPRequest {
+    return new HTTPRequest(hooks, method, url);
+  }
+};
+
+export default HTTP;

package/src/runtimes/isomorphic/http/http_xhr_request.ts

@@ -0,0 +1,35 @@
+import HTTPRequest from 'core/http/http_request';
+import RequestHooks from 'core/http/request_hooks';
+import Ajax from 'core/http/ajax';
+import Runtime from 'runtime';
+
+var hooks: RequestHooks = {
+  getRequest: function(socket: HTTPRequest): Ajax {
+    var Constructor = Runtime.getXHRAPI();
+    var xhr = new Constructor();
+    xhr.onreadystatechange = xhr.onprogress = function() {
+      switch (xhr.readyState) {
+        case 3:
+          if (xhr.responseText && xhr.responseText.length > 0) {
+            socket.onChunk(xhr.status, xhr.responseText);
+          }
+          break;
+        case 4:
+          // this happens only on errors, never after calling close
+          if (xhr.responseText && xhr.responseText.length > 0) {
+            socket.onChunk(xhr.status, xhr.responseText);
+          }
+          socket.emit('finished', xhr.status);
+          socket.close();
+          break;
+      }
+    };
+    return xhr;
+  },
+  abortRequest: function(xhr: Ajax) {
+    xhr.onreadystatechange = null;
+    xhr.abort();
+  }
+};
+
+export default hooks;

package/src/runtimes/isomorphic/runtime.ts

@@ -0,0 +1,62 @@
+import * as Collections from 'core/utils/collections';
+import Transports from 'isomorphic/transports/transports';
+import TimelineSender from 'core/timeline/timeline_sender';
+import Ajax from 'core/http/ajax';
+import getDefaultStrategy from './default_strategy';
+import TransportsTable from 'core/transports/transports_table';
+import transportConnectionInitializer from './transports/transport_connection_initializer';
+import HTTPFactory from './http/http';
+
+var Isomorphic: any = {
+  getDefaultStrategy,
+  Transports: <TransportsTable>Transports,
+  transportConnectionInitializer,
+  HTTPFactory,
+
+  setup(PusherClass): void {
+    PusherClass.ready();
+  },
+
+  getLocalStorage(): any {
+    return undefined;
+  },
+
+  getClientFeatures(): any[] {
+    return Collections.keys(
+      Collections.filterObject({ ws: Transports.ws }, function(t) {
+        return t.isSupported({});
+      })
+    );
+  },
+
+  getProtocol(): string {
+    return 'http:';
+  },
+
+  isXHRSupported(): boolean {
+    return true;
+  },
+
+  createSocketRequest(method: string, url: string) {
+    if (this.isXHRSupported()) {
+      return this.HTTPFactory.createXHR(method, url);
+    } else {
+      throw 'Cross-origin HTTP requests are not supported';
+    }
+  },
+
+  createXHR(): Ajax {
+    var Constructor = this.getXHRAPI();
+    return new Constructor();
+  },
+
+  createWebSocket(url: string): any {
+    var Constructor = this.getWebSocketAPI();
+    return new Constructor(url);
+  },
+
+  addUnloadListener(listener: any) {},
+  removeUnloadListener(listener: any) {}
+};
+
+export default Isomorphic;

package/src/runtimes/isomorphic/timeline/xhr_timeline.ts

@@ -0,0 +1,50 @@
+import Logger from 'core/logger';
+import TimelineSender from 'core/timeline/timeline_sender';
+import * as Collections from 'core/utils/collections';
+import Util from 'core/util';
+import Runtime from 'runtime';
+import TimelineTransport from 'core/timeline/timeline_transport';
+
+var getAgent = function(sender: TimelineSender, useTLS: boolean) {
+  return function(data: any, callback: Function) {
+    var scheme = 'http' + (useTLS ? 's' : '') + '://';
+    var url =
+      scheme + (sender.host || sender.options.host) + sender.options.path;
+    var query = Collections.buildQueryString(data);
+
+    url += '/' + 2 + '?' + query;
+
+    var xhr = Runtime.createXHR();
+    xhr.open('GET', url, true);
+
+    xhr.onreadystatechange = function() {
+      if (xhr.readyState === 4) {
+        let { status, responseText } = xhr;
+        if (status !== 200) {
+          Logger.debug(
+            `TimelineSender Error: received ${status} from stats.pusher.com`
+          );
+          return;
+        }
+
+        try {
+          var { host } = JSON.parse(responseText);
+        } catch (e) {
+          Logger.debug(`TimelineSenderError: invalid response ${responseText}`);
+        }
+        if (host) {
+          sender.host = host;
+        }
+      }
+    };
+
+    xhr.send();
+  };
+};
+
+var xhr = {
+  name: 'xhr',
+  getAgent
+};
+
+export default xhr;

package/src/runtimes/isomorphic/transports/transport_connection_initializer.ts

@@ -0,0 +1,19 @@
+/** Initializes the transport.
+ *
+ * Fetches resources if needed and then transitions to initialized.
+ */
+export default function() {
+  var self = this;
+
+  self.timeline.info(
+    self.buildTimelineMessage({
+      transport: self.name + (self.options.useTLS ? 's' : '')
+    })
+  );
+
+  if (self.hooks.isInitialized()) {
+    self.changeState('initialized');
+  } else {
+    self.onClose();
+  }
+}

package/src/runtimes/isomorphic/transports/transports.ts

@@ -0,0 +1,81 @@
+import * as URLSchemes from 'core/transports/url_schemes';
+import URLScheme from 'core/transports/url_scheme';
+import Transport from 'core/transports/transport';
+import Util from 'core/util';
+import * as Collections from 'core/utils/collections';
+import TransportHooks from 'core/transports/transport_hooks';
+import TransportsTable from 'core/transports/transports_table';
+import Runtime from 'runtime';
+
+/** WebSocket transport.
+ *
+ * Uses native WebSocket implementation, including MozWebSocket supported by
+ * earlier Firefox versions.
+ */
+var WSTransport = new Transport(<TransportHooks>{
+  urls: URLSchemes.ws,
+  handlesActivityChecks: false,
+  supportsPing: false,
+
+  isInitialized: function() {
+    return Boolean(Runtime.getWebSocketAPI());
+  },
+  isSupported: function(): boolean {
+    return Boolean(Runtime.getWebSocketAPI());
+  },
+  getSocket: function(url) {
+    return Runtime.createWebSocket(url);
+  }
+});
+
+var httpConfiguration = {
+  urls: URLSchemes.http,
+  handlesActivityChecks: false,
+  supportsPing: true,
+  isInitialized: function() {
+    return true;
+  }
+};
+
+export var streamingConfiguration = Collections.extend(
+  {
+    getSocket: function(url) {
+      return Runtime.HTTPFactory.createStreamingSocket(url);
+    }
+  },
+  httpConfiguration
+);
+export var pollingConfiguration = Collections.extend(
+  {
+    getSocket: function(url) {
+      return Runtime.HTTPFactory.createPollingSocket(url);
+    }
+  },
+  httpConfiguration
+);
+
+var xhrConfiguration = {
+  isSupported: function(): boolean {
+    return Runtime.isXHRSupported();
+  }
+};
+
+/** HTTP streaming transport using CORS-enabled XMLHttpRequest. */
+var XHRStreamingTransport = new Transport(
+  <TransportHooks>(
+    Collections.extend({}, streamingConfiguration, xhrConfiguration)
+  )
+);
+
+/** HTTP long-polling transport using CORS-enabled XMLHttpRequest. */
+var XHRPollingTransport = new Transport(
+  <TransportHooks>Collections.extend({}, pollingConfiguration, xhrConfiguration)
+);
+
+var Transports: TransportsTable = {
+  ws: WSTransport,
+  xhr_streaming: XHRStreamingTransport,
+  xhr_polling: XHRPollingTransport
+};
+
+export default Transports;

package/src/runtimes/node/net_info.ts

@@ -0,0 +1,10 @@
+import { default as EventsDispatcher } from 'core/events/dispatcher';
+import Reachability from 'core/reachability';
+
+export class NetInfo extends EventsDispatcher implements Reachability {
+  isOnline(): boolean {
+    return true;
+  }
+}
+
+export var Network = new NetInfo();

package/src/runtimes/node/runtime.ts

@@ -0,0 +1,68 @@
+import Isomorphic from 'isomorphic/runtime';
+import { Client as WebSocket } from 'faye-websocket';
+import { XMLHttpRequest } from 'xmlhttprequest';
+import Runtime from '../interface';
+import { Network } from './net_info';
+import xhrAuth from 'isomorphic/auth/xhr_auth';
+import { AuthTransports } from 'core/auth/auth_transports';
+import xhrTimeline from 'isomorphic/timeline/xhr_timeline';
+import { randomInt } from 'crypto';
+
+// Very verbose but until unavoidable until
+// TypeScript 2.1, when spread attributes will be
+// supported
+const {
+  getDefaultStrategy,
+  Transports,
+  setup,
+  getProtocol,
+  isXHRSupported,
+  getLocalStorage,
+  createXHR,
+  createWebSocket,
+  addUnloadListener,
+  removeUnloadListener,
+  transportConnectionInitializer,
+  createSocketRequest,
+  HTTPFactory
+} = Isomorphic;
+
+const NodeJS: Runtime = {
+  getDefaultStrategy,
+  Transports,
+  setup,
+  getProtocol,
+  isXHRSupported,
+  createSocketRequest,
+  getLocalStorage,
+  createXHR,
+  createWebSocket,
+  addUnloadListener,
+  removeUnloadListener,
+  transportConnectionInitializer,
+  HTTPFactory,
+
+  TimelineTransport: xhrTimeline,
+
+  getAuthorizers(): AuthTransports {
+    return { ajax: xhrAuth };
+  },
+
+  getWebSocketAPI() {
+    return WebSocket;
+  },
+
+  getXHRAPI() {
+    return XMLHttpRequest;
+  },
+
+  getNetwork() {
+    return Network;
+  },
+
+  randomInt(max: number): number {
+    return randomInt(max);
+  }
+};
+
+export default NodeJS;