Subscriptions upgrade

Cached Subscription
Docs
Misc fixes

demo/doubleSubscription.html

@@ -31,8 +31,8 @@
                 document.getElementById('extension').style.display = 'block';
 
                 var subscription1 = rcsdk
-                        .createSubscription()
-                        .restoreFromCache('subscription', ['/account/~/extension/~/presence']);
+                        .createCachedSubscription('subscription')
+                        .restore(['/account/~/extension/~/presence']);
 
                 console.log('Cached subscription data', subscription1.subscription(), 'alive', subscription1.alive());
 

docs/migration-1.x-2.0.md

@@ -4,8 +4,10 @@ Key differences:
 
 - Helpers were moved to separate repository: [RingCentral JS Helpers](https://github.com/ringcentral/ringcentral-js-helpers).
 - Root JS name has changed from `RCSDK` to `RingCentral.SDK`
+- New naming convention: `getSomething()` methods are now simply `something()`
+- `Auth` class inside `Platform`
 - `AjaxObserver` functionality been moved to `Client`
-- New network request/response objects `ApiResponse` interface:
+- New `ApiResponse` interface that wraps network Requests/Responses:
     - `apiResponse.json()` instead of `ajax.json`
     - `apiResponse.multipart()` instead of `ajax.responses`
     - `apiResponse.request()` and `ajax.response()` to access to DOM Request and DOM Response accordingly

src/SDK.js

@@ -2,6 +2,7 @@ import * as Utils from './core/Utils';
 import Cache from './core/Cache';
 import * as Externals from './core/Externals';
 import Observable from './core/Observable';
+import Queue from './core/Queue';
 
 import Client from './http/Client';
 import ApiResponse from './http/ApiResponse';
@@ -13,11 +14,11 @@ import Registry from './mocks/Registry';
 
 import Platform from './platform/Platform';
 import Auth from './platform/Auth';
-import Queue from './platform/Queue';
 
 import PubnubMockFactory from './pubnub/PubnubFactory';
 
 import Subscription from './subscription/Subscription';
+import CachedSubscription from './subscription/CachedSubscription';
 
 require("regenerator/runtime");
 
@@ -67,7 +68,14 @@ export default class SDK {
      * @return {Subscription}
      */
     createSubscription() {
-        return new Subscription(this._pubnubFactory, this._platform, this._cache);
+        return new Subscription(this._pubnubFactory, this._platform);
+    }
+
+    /**
+     * @return {CachedSubscription}
+     */
+    createCachedSubscription(cacheKey) {
+        return new CachedSubscription(this._pubnubFactory, this._platform, this._cache, cacheKey);
     }
 
     /**
@@ -81,7 +89,8 @@ export default class SDK {
         Cache: Cache,
         Observable: Observable,
         Utils: Utils,
-        Externals: Externals
+        Externals: Externals,
+        Queue: Queue
     };
 
     static http = {
@@ -92,8 +101,7 @@ export default class SDK {
 
     static platform = {
         Auth: Auth,
-        Platform: Platform,
-        Queue: Queue
+        Platform: Platform
     };
 
     static subscription = {

src/core/Externals.js

@@ -2,14 +2,15 @@ import ES6Promise from 'es6-promise';
 import nodeFetch from 'node-fetch';
 import pubnub from 'pubnub';
 
-export var Promise = (ES6Promise && ES6Promise.Promise) || window.Promise;
+var root = (new Function('return this'))();
 
-export var fetch = nodeFetch || window.fetch;
-export var Request = fetch.Request || window.Request;
-export var Response = fetch.Response || window.Response;
-export var Headers = fetch.Headers || window.Headers;
+export var Promise = (ES6Promise && ES6Promise.Promise) || root.Promise;
 
-export var PUBNUB = pubnub || window.PUBNUB;
+export var fetch = root.fetch || nodeFetch;
+export var Request = root.Request || fetch.Request;
+export var Response = root.Response || fetch.Response;
+export var Headers = root.Headers || fetch.Headers;
 
-export var localStorage = (typeof window !== 'undefined' &&
-                           typeof window.localStorage !== 'undefined') ? window.localStorage : {};
+export var PUBNUB = root.PUBNUB || pubnub;
+
+export var localStorage = (typeof root.localStorage !== 'undefined') ? root.localStorage : {};

src/platform/Queue-spec.js → src/core/Queue-spec.js

@@ -1,13 +1,13 @@
 import {expect, getSdk, getMock, getRegistry} from '../test/test';
 import SDK from '../SDK';
 
-describe('RingCentral.platform.Queue', function() {
+describe('RingCentral.core.Queue', function() {
 
-    var pollInterval = SDK.platform.Queue._pollInterval,
-        releaseTimeout = SDK.platform.Queue._releaseTimeout;
+    var pollInterval = SDK.core.Queue._pollInterval,
+        releaseTimeout = SDK.core.Queue._releaseTimeout;
 
     function getQueue() {
-        return new SDK.platform.Queue(new SDK.core.Cache({}), 'foo');
+        return new SDK.core.Queue(new SDK.core.Cache({}), 'foo');
     }
 
     describe('poll', function() {

src/platform/Queue.js → src/core/Queue.js

@@ -1,5 +1,5 @@
 import {Promise} from '../core/Externals';
-import {poll, stopPolling} from '../core/Utils';
+import {poll, stopPolling} from './Utils';
 
 export default class Queue {
 
@@ -16,9 +16,7 @@ export default class Queue {
 
     isPaused() {
 
-        var storage = this._cache,
-            cacheId = this._cacheId,
-            time = storage.getItem(cacheId);
+        var time = this._cache.getItem(this._cacheId);
 
         return !!time && Date.now() - parseInt(time) < Queue._releaseTimeout;
     }

src/platform/Platform.js

@@ -1,5 +1,5 @@
 import Observable from '../core/Observable';
-import Queue from './Queue';
+import Queue from '../core/Queue';
 import Auth from './Auth';
 import {Promise} from '../core/Externals';
 import {queryStringify, parseQueryString, delay} from '../core/Utils';
@@ -372,8 +372,8 @@ export default class Platform extends Observable {
 
     /**
      * General purpose function to send anything to server
+     * @param {string} options.url
      * @param {object} [options.body]
-     * @param {string} [options.url]
      * @param {string} [options.method]
      * @param {object} [options.query]
      * @param {object} [options.headers]
@@ -391,7 +391,7 @@ export default class Platform extends Observable {
 
     /**
      * @param {string} url
-     * @param {object} query
+     * @param {object} [query]
      * @param {object} [options]
      * @param {object} [options.headers]
      * @param {boolean} [options.skipAuthCheck]
@@ -408,7 +408,7 @@ export default class Platform extends Observable {
     /**
      * @param {string} url
      * @param {object} body
-     * @param {object} query
+     * @param {object} [query]
      * @param {object} [options]
      * @param {object} [options.headers]
      * @param {boolean} [options.skipAuthCheck]
@@ -425,8 +425,8 @@ export default class Platform extends Observable {
 
     /**
      * @param {string} url
-     * @param {object} body
-     * @param {object} query
+     * @param {object} [body]
+     * @param {object} [query]
      * @param {object} [options]
      * @param {object} [options.headers]
      * @param {boolean} [options.skipAuthCheck]
@@ -443,7 +443,7 @@ export default class Platform extends Observable {
 
     /**
      * @param {string} url
-     * @param {string} query
+     * @param {string} [query]
      * @param {object} [options]
      * @param {object} [options.headers]
      * @param {boolean} [options.skipAuthCheck]

src/subscription/CachedSubscription-spec.js

@@ -0,0 +1,21 @@
+import {expect, getSdk, getMock, getRegistry, spy} from '../test/test';
+import SDK from '../SDK';
+
+describe('RingCentral.subscription.CachedSubscription', function() {
+
+    describe('restore', function() {
+
+        it.skip('sets appropriate event filters if subscription is not alive', function() {});
+        it.skip('sets appropriate event filters if subscription is never existed', function() {});
+        it.skip('renews subscription if cache data is OK', function() {});
+        it.skip('re-subscribes with default event filters when renew fails', function() {});
+
+    });
+
+    describe('renew', function() {
+    });
+
+    describe('resubscribe', function() {
+    });
+
+});

src/subscription/CachedSubscription.js

@@ -0,0 +1,135 @@
+import Subscription from './Subscription';
+import Queue from '../core/Queue';
+
+export default class CachedSubscription extends Subscription {
+
+    constructor(pubnubFactory, platform, cache, cacheKey) {
+
+        super(pubnubFactory, platform);
+
+        this._cache = cache;
+        this._cacheKey = cacheKey;
+        this._renewQueue = new Queue(this._cache, cacheKey + '-renew');
+        this._resubscribeQueue = new Queue(this._cache, cacheKey + '-resubscribe');
+
+        this.events = {
+            ...this.events,
+            queuedRenewSuccess: 'queuedRenewSuccess',
+            queuedRenewError: 'queuedRenewError',
+            queuedResubscribeSuccess: 'queuedResubscribeSuccess',
+            queuedResubscribeError: 'queuedResubscribeError'
+        };
+
+        this.on(this.events.renewError, () => {
+            this.resubscribe();
+        });
+
+        this.on([this.events.subscribeSuccess, this.events.renewSuccess], () => {
+            this._cache.setItem(this._cacheKey, this.subscription());
+        });
+
+        this.on(this.events.removeSuccess, () => {
+            this._cache.removeItem(this._cacheKey);
+        });
+
+    }
+
+    /**
+     * TODO Combine with Platform.refresh and move elsewhere
+     * @param actionCb
+     * @param queue
+     * @param successEvent
+     * @param errorEvent
+     * @param errorMessage
+     * @return {*}
+     * @private
+     */
+    async _queue(actionCb, queue, successEvent, errorEvent, errorMessage) {
+
+        try {
+
+            if (queue.isPaused()) {
+
+                await queue.poll();
+
+                if (!this.alive()) {
+                    throw new Error(errorMessage);
+                }
+
+                this.emit(successEvent, null);
+
+                return null;
+
+            }
+
+            queue.pause();
+
+            var res = await actionCb.call(this);
+
+            queue.resume();
+
+            this.emit(successEvent, res);
+
+            return res;
+
+        } catch (e) {
+
+            this.emit(errorEvent, e);
+
+            throw e;
+
+        }
+
+    }
+
+    /**
+     * @returns {Promise<ApiResponse>}
+     */
+    renew() {
+
+        return this._queue(
+            super.renew,
+            this._renewQueue,
+            this.events.queuedRenewSuccess,
+            this.events.queuedRenewError,
+            'Subscription is not alive after renew timeout'
+        );
+
+    }
+
+    /**
+     * @returns {Promise<ApiResponse>}
+     */
+    resubscribe() {
+
+        return this._queue(
+            super.resubscribe,
+            this._resubscribeQueue,
+            this.events.queuedResubscribeSuccess,
+            this.events.queuedResubscribeError,
+            'Subscription is not alive after resubscribe timeout'
+        );
+
+    }
+
+    /**
+     * @param {string[]} events
+     * @return {CachedSubscription}
+     */
+    restore(events) {
+
+        var cachedSubscriptionData = this._cache.getItem(this._cacheKey);
+
+        if (cachedSubscriptionData) {
+            try {
+                this.setSubscription(cachedSubscriptionData);
+            } catch (e) {}
+        } else {
+            this.setEventFilters(events);
+        }
+
+        return this;
+
+    }
+
+}