relay-runtime 1.3.0 → 1.5.0

package/lib/RelayObservable.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule RelayObservable
  * 
@@ -17,9 +15,44 @@ var _classCallCheck3 = _interopRequireDefault(require('babel-runtime/helpers/cla
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 
+/**
+ * A Subscription object is returned from .subscribe(), which can be
+ * unsubscribed or checked to see if the resulting subscription has closed.
+ */
+
+
+/**
+ * An Observer is an object of optional callback functions provided to
+ * .subscribe(). Each callback function is invoked when that event occurs.
+ */
+
+
+/**
+ * A Sink is an object of methods provided by Observable during construction.
+ * The methods are to be called to trigger each event. It also contains a closed
+ * field to see if the resulting subscription has closed.
+ */
+
+
+/**
+ * A Source is the required argument when constructing a new Observable. Similar
+ * to a Promise constructor, this is a function which is invoked with a Sink,
+ * and may return either a cleanup function or a Subscription instance (for use
+ * when composing Observables).
+ */
+
+
+/**
+ * A Subscribable is an interface describing any object which can be subscribed.
+ *
+ * Note: A sink may be passed directly to .subscribe() as its observer,
+ * allowing for easily composing Subscribables.
+ */
+
+
 // Note: This should accept Subscribable<T> instead of RelayObservable<T>,
 // however Flow cannot yet distinguish it from T.
-var hostReportError = void 0;
+var hostReportError = swallowError;
 
 /**
  * Limited implementation of ESObservable, providing the limited set of behavior
@@ -34,6 +67,13 @@ var hostReportError = void 0;
  */
 
 var RelayObservable = function () {
+  RelayObservable.create = function create(source) {
+    return new RelayObservable(source);
+  };
+
+  // Use RelayObservable.create()
+
+
   function RelayObservable(source) {
     (0, _classCallCheck3['default'])(this, RelayObservable);
 
@@ -47,16 +87,29 @@ var RelayObservable = function () {
   }
 
   /**
-   * When an unhandled error is detected, it is reported to the host environment
-   * (the ESObservable spec refers to this method as "HostReportErrors()").
+   * When an emitted error event is not handled by an Observer, it is reported
+   * to the host environment (what the ESObservable spec refers to as
+   * "HostReportErrors()").
    *
-   * The default implementation in development builds re-throws errors in a
-   * separate frame, and from production builds does nothing (swallowing
-   * uncaught errors).
+   * The default implementation in development rethrows thrown errors, and
+   * logs emitted error events to the console, while in production does nothing
+   * (swallowing unhandled errors).
    *
    * Called during application initialization, this method allows
-   * application-specific handling of uncaught errors. Allowing, for example,
+   * application-specific handling of unhandled errors. Allowing, for example,
    * integration with error logging or developer tools.
+   *
+   * A second parameter `isUncaughtThrownError` is true when the unhandled error
+   * was thrown within an Observer handler, and false when the unhandled error
+   * was an unhandled emitted event.
+   *
+   *  - Uncaught thrown errors typically represent avoidable errors thrown from
+   *    application code, which should be handled with a try/catch block, and
+   *    usually have useful stack traces.
+   *
+   *  - Unhandled emitted event errors typically represent unavoidable events in
+   *    application flow such as network failure, and may not have useful
+   *    stack traces.
    */
 
 
@@ -71,7 +124,7 @@ var RelayObservable = function () {
 
 
   RelayObservable.from = function from(obj) {
-    return isObservable(obj) ? fromObservable(obj) : require('./isPromise')(obj) ? fromPromise(obj) : obj instanceof Error ? fromError(obj) : fromValue(obj);
+    return isObservable(obj) ? fromObservable(obj) : require('./isPromise')(obj) ? fromPromise(obj) : fromValue(obj);
   };
 
   /**
@@ -84,7 +137,7 @@ var RelayObservable = function () {
 
 
   RelayObservable.fromLegacy = function fromLegacy(callback) {
-    return new RelayObservable(function (sink) {
+    return RelayObservable.create(function (sink) {
       var result = callback({
         onNext: sink.next,
         onError: sink.error,
@@ -108,7 +161,7 @@ var RelayObservable = function () {
   RelayObservable.prototype['catch'] = function _catch(fn) {
     var _this = this;
 
-    return new RelayObservable(function (sink) {
+    return RelayObservable.create(function (sink) {
       var subscription = void 0;
       _this.subscribe({
         start: function start(sub) {
@@ -116,13 +169,13 @@ var RelayObservable = function () {
         },
         next: sink.next,
         complete: sink.complete,
-        error: function (_error) {
+        error: function (_error2) {
           function error(_x) {
-            return _error.apply(this, arguments);
+            return _error2.apply(this, arguments);
           }
 
           error.toString = function () {
-            return _error.toString();
+            return _error2.toString();
           };
 
           return error;
@@ -137,7 +190,7 @@ var RelayObservable = function () {
               error: sink.error
             });
           } catch (error2) {
-            sink.error(error2);
+            sink.error(error2, true /* isUncaughtThrownError */);
           }
         })
       });
@@ -153,7 +206,7 @@ var RelayObservable = function () {
    * for all events emitted by the source.
    *
    * Any errors that are thrown in the side-effect Observer are unhandled, and
-   * do not effect the source Observable or its Observer.
+   * do not affect the source Observable or its Observer.
    *
    * This is useful for when debugging your Observables or performing other
    * side-effects such as logging or performance monitoring.
@@ -163,13 +216,13 @@ var RelayObservable = function () {
   RelayObservable.prototype['do'] = function _do(observer) {
     var _this2 = this;
 
-    return new RelayObservable(function (sink) {
+    return RelayObservable.create(function (sink) {
       var both = function both(action) {
         return function () {
           try {
             observer[action] && observer[action].apply(observer, arguments);
           } catch (error) {
-            handleError(error);
+            hostReportError(error, true /* isUncaughtThrownError */);
           }
           sink[action] && sink[action].apply(sink, arguments);
         };
@@ -184,6 +237,27 @@ var RelayObservable = function () {
     });
   };
 
+  /**
+   * Returns a new Observable which returns the same values as this one, but
+   * modified so that the finally callback is performed after completion,
+   * whether normal or due to error or unsubscription.
+   *
+   * This is useful for cleanup such as resource finalization.
+   */
+
+
+  RelayObservable.prototype['finally'] = function _finally(fn) {
+    var _this3 = this;
+
+    return RelayObservable.create(function (sink) {
+      var subscription = _this3.subscribe(sink);
+      return function () {
+        subscription.unsubscribe();
+        fn();
+      };
+    });
+  };
+
   /**
    * Returns a new Observable which is identical to this one, unless this
    * Observable completes before yielding any values, in which case the new
@@ -197,11 +271,11 @@ var RelayObservable = function () {
 
 
   RelayObservable.prototype.ifEmpty = function ifEmpty(alternate) {
-    var _this3 = this;
+    var _this4 = this;
 
-    return new RelayObservable(function (sink) {
+    return RelayObservable.create(function (sink) {
       var hasValue = false;
-      var current = _this3.subscribe({
+      var current = _this4.subscribe({
         next: function next(value) {
           hasValue = true;
           sink.next(value);
@@ -225,6 +299,9 @@ var RelayObservable = function () {
   /**
    * Observable's primary API: returns an unsubscribable Subscription to the
    * source of this Observable.
+   *
+   * Note: A sink may be passed directly to .subscribe() as its observer,
+   * allowing for easily composing Observables.
    */
 
 
@@ -261,7 +338,7 @@ var RelayObservable = function () {
 
 
   RelayObservable.prototype.map = function map(fn) {
-    return this.concatMap(function (value) {
+    return this.mergeMap(function (value) {
       return fromValue(fn(value));
     });
   };
@@ -269,66 +346,54 @@ var RelayObservable = function () {
   /**
    * Returns a new Observable where each value is replaced with a new Observable
    * by the mapping function, the results of which returned as a single
-   * concattenated Observable.
+   * merged Observable.
    */
 
 
-  RelayObservable.prototype.concatMap = function concatMap(fn) {
-    var _this4 = this;
+  RelayObservable.prototype.mergeMap = function mergeMap(fn) {
+    var _this5 = this;
 
-    return new RelayObservable(function (sink) {
-      var hasCompleted = false;
-      var outer = void 0;
-      var inner = void 0;
-      var buffer = [];
+    return RelayObservable.create(function (sink) {
+      var subscriptions = [];
 
-      function next(value) {
-        if (inner) {
-          buffer.push(value);
-        } else {
-          try {
-            RelayObservable.from(fn(value)).subscribe({
-              start: function start(sub) {
-                inner = sub;
-              },
-              next: sink.next,
-              error: sink.error,
-              complete: function complete() {
-                inner = undefined;
-                if (buffer.length !== 0) {
-                  next(buffer.shift());
-                } else if (hasCompleted) {
-                  sink.complete();
-                }
-              }
-            });
-          } catch (error) {
-            sink.error(error);
-          }
+      function start(subscription) {
+        this._sub = subscription;
+        subscriptions.push(subscription);
+      }
+
+      function complete() {
+        subscriptions.splice(subscriptions.indexOf(this._sub), 1);
+        if (subscriptions.length === 0) {
+          sink.complete();
         }
       }
 
-      _this4.subscribe({
-        start: function start(sub) {
-          outer = sub;
+      _this5.subscribe({
+        start: start,
+        next: function next(value) {
+          try {
+            if (!sink.closed) {
+              RelayObservable.from(fn(value)).subscribe({
+                start: start,
+                next: sink.next,
+                error: sink.error,
+                complete: complete
+              });
+            }
+          } catch (error) {
+            sink.error(error, true /* isUncaughtThrownError */);
+          }
         },
-        next: next,
+
         error: sink.error,
-        complete: function complete() {
-          hasCompleted = true;
-          if (!inner) {
-            sink.complete();
-          }
-        }
+        complete: complete
       });
 
       return function () {
-        if (inner) {
-          inner.unsubscribe();
-          inner = undefined;
-        }
-        outer.unsubscribe();
-        buffer.length = 0;
+        subscriptions.forEach(function (sub) {
+          return sub.unsubscribe();
+        });
+        subscriptions.length = 0;
       };
     });
   };
@@ -343,18 +408,18 @@ var RelayObservable = function () {
 
 
   RelayObservable.prototype.poll = function poll(pollInterval) {
-    var _this5 = this;
+    var _this6 = this;
 
     if (process.env.NODE_ENV !== 'production') {
       if (typeof pollInterval !== 'number' || pollInterval <= 0) {
         throw new Error('RelayObservable: Expected pollInterval to be positive, got: ' + pollInterval);
       }
     }
-    return new RelayObservable(function (sink) {
+    return RelayObservable.create(function (sink) {
       var subscription = void 0;
       var timeout = void 0;
       var poll = function poll() {
-        subscription = _this5.subscribe({
+        subscription = _this6.subscribe({
           next: sink.next,
           error: sink.error,
           complete: function complete() {
@@ -377,11 +442,11 @@ var RelayObservable = function () {
 
 
   RelayObservable.prototype.toPromise = function toPromise() {
-    var _this6 = this;
+    var _this7 = this;
 
     return new Promise(function (resolve, reject) {
       var subscription = void 0;
-      _this6.subscribe({
+      _this7.subscribe({
         start: function start(sub) {
           subscription = sub;
         },
@@ -402,19 +467,18 @@ var RelayObservable = function () {
 // Use declarations to teach Flow how to check isObservable.
 
 
-// eslint-disable-next-line no-redeclare
 function isObservable(obj) {
   return typeof obj === 'object' && obj !== null && typeof obj.subscribe === 'function';
 }
 
 function fromObservable(obj) {
-  return obj instanceof RelayObservable ? obj : new RelayObservable(function (sink) {
+  return obj instanceof RelayObservable ? obj : RelayObservable.create(function (sink) {
     return obj.subscribe(sink);
   });
 }
 
 function fromPromise(promise) {
-  return new RelayObservable(function (sink) {
+  return RelayObservable.create(function (sink) {
     // Since sink methods do not throw, the resulting Promise can be ignored.
     promise.then(function (value) {
       sink.next(value);
@@ -424,26 +488,26 @@ function fromPromise(promise) {
 }
 
 function fromValue(value) {
-  return new RelayObservable(function (sink) {
+  return RelayObservable.create(function (sink) {
     sink.next(value);
     sink.complete();
   });
 }
 
-function fromError(error) {
-  return new RelayObservable(function (sink) {
-    sink.error(error);
-  });
-}
-
-function handleError(error) {
-  hostReportError && hostReportError(error);
-}
-
 function _subscribe(source, observer) {
   var closed = false;
   var cleanup = void 0;
 
+  // Ideally we would simply describe a `get closed()` method on the Sink and
+  // Subscription objects below, however not all flow environments we expect
+  // Relay to be used within will support property getters, and many minifier
+  // tools still do not support ES5 syntax. Instead, we can use defineProperty.
+  var withClosed = function withClosed(obj) {
+    return Object.defineProperty(obj, 'closed', { get: function get() {
+        return closed;
+      } });
+  };
+
   function doCleanup() {
     if (cleanup) {
       if (cleanup.unsubscribe) {
@@ -452,7 +516,7 @@ function _subscribe(source, observer) {
         try {
           cleanup();
         } catch (error) {
-          handleError(error);
+          hostReportError(error, true /* isUncaughtThrownError */);
         }
       }
       cleanup = undefined;
@@ -460,7 +524,7 @@ function _subscribe(source, observer) {
   }
 
   // Create a Subscription.
-  var subscription = {
+  var subscription = withClosed({
     unsubscribe: function unsubscribe() {
       if (!closed) {
         closed = true;
@@ -469,19 +533,19 @@ function _subscribe(source, observer) {
         try {
           observer.unsubscribe && observer.unsubscribe(subscription);
         } catch (error) {
-          handleError(error);
+          hostReportError(error, true /* isUncaughtThrownError */);
         } finally {
           doCleanup();
         }
       }
     }
-  };
+  });
 
   // Tell Observer that observation is about to begin.
   try {
     observer.start && observer.start(subscription);
   } catch (error) {
-    handleError(error);
+    hostReportError(error, true /* isUncaughtThrownError */);
   }
 
   // If closed already, don't bother creating a Sink.
@@ -490,40 +554,40 @@ function _subscribe(source, observer) {
   }
 
   // Create a Sink respecting subscription state and cleanup.
-  var sink = {
+  var sink = withClosed({
     next: function next(value) {
       if (!closed && observer.next) {
         try {
           observer.next(value);
         } catch (error) {
-          handleError(error);
+          hostReportError(error, true /* isUncaughtThrownError */);
         }
       }
     },
-    error: function (_error2) {
-      function error(_x2) {
-        return _error2.apply(this, arguments);
+    error: function (_error3) {
+      function error(_x2, _x3) {
+        return _error3.apply(this, arguments);
       }
 
       error.toString = function () {
-        return _error2.toString();
+        return _error3.toString();
       };
 
       return error;
-    }(function (error) {
-      try {
-        if (closed) {
-          throw error;
-        }
+    }(function (error, isUncaughtThrownError) {
+      if (closed || !observer.error) {
         closed = true;
-        if (!observer.error) {
-          throw error;
-        }
-        observer.error(error);
-      } catch (error2) {
-        handleError(error2);
-      } finally {
+        hostReportError(error, isUncaughtThrownError || false);
         doCleanup();
+      } else {
+        closed = true;
+        try {
+          observer.error(error);
+        } catch (error2) {
+          hostReportError(error2, true /* isUncaughtThrownError */);
+        } finally {
+          doCleanup();
+        }
       }
     }),
     complete: function complete() {
@@ -532,19 +596,19 @@ function _subscribe(source, observer) {
         try {
           observer.complete && observer.complete();
         } catch (error) {
-          handleError(error);
+          hostReportError(error, true /* isUncaughtThrownError */);
         } finally {
           doCleanup();
         }
       }
     }
-  };
+  });
 
   // If anything goes wrong during observing the source, handle the error.
   try {
     cleanup = source(sink);
   } catch (error) {
-    sink.error(error);
+    sink.error(error, true /* isUncaughtThrownError */);
   }
 
   if (process.env.NODE_ENV !== 'production') {
@@ -562,18 +626,27 @@ function _subscribe(source, observer) {
   return subscription;
 }
 
+function swallowError(_error, _isUncaughtThrownError) {
+  // do nothing.
+}
+
 if (process.env.NODE_ENV !== 'production') {
   // Default implementation of HostReportErrors() in development builds.
   // Can be replaced by the host application environment.
-  RelayObservable.onUnhandledError(function (error) {
+  RelayObservable.onUnhandledError(function (error, isUncaughtThrownError) {
     if (typeof fail === 'function') {
       // In test environments (Jest), fail() immediately fails the current test.
       fail(String(error));
-    } else {
-      // Otherwise, rethrow on the next frame to avoid breaking current logic.
+    } else if (isUncaughtThrownError) {
+      // Rethrow uncaught thrown errors on the next frame to avoid breaking
+      // current logic.
       setTimeout(function () {
         throw error;
       });
+    } else if (typeof console !== 'undefined') {
+      // Otherwise, log the unhandled error for visibility.
+      // eslint-ignore-next-line no-console
+      console.error('RelayObservable: Unhandled Error', error);
     }
   });
 }

package/lib/RelayProfiler.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule RelayProfiler
  * 
@@ -78,9 +76,11 @@ var RelayProfiler = {
    * `attachHandler` and `detachHandler` methods.
    */
   instrumentMethods: function instrumentMethods(object, names) {
-    require('fbjs/lib/forEachObject')(names, function (name, key) {
-      object[key] = RelayProfiler.instrument(name, object[key]);
-    });
+    for (var _key in names) {
+      if (names.hasOwnProperty(_key)) {
+        object[_key] = RelayProfiler.instrument(names[_key], object[_key]);
+      }
+    }
   },
 
 

package/lib/RelayPublishQueue.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * 
  * @providesModule RelayPublishQueue
@@ -237,10 +235,15 @@ var RelayPublishQueue = function () {
               selectorData = lookupSelector(_source, _operation.fragment);
             }
             selectorStoreUpdater && selectorStoreUpdater(selectorStore, selectorData);
-          } else {
+          } else if (optimisticUpdate.storeUpdater) {
             var storeUpdater = optimisticUpdate.storeUpdater;
 
             storeUpdater(store);
+          } else {
+            var _source2 = optimisticUpdate.source,
+                _fieldPayloads = optimisticUpdate.fieldPayloads;
+
+            store.publishSource(_source2, _fieldPayloads);
           }
         });
       }
@@ -256,19 +259,24 @@ var RelayPublishQueue = function () {
             var selectorStore = store.commitPayload(_operation2, response);
             // TODO: Fix commitPayload so we don't have to run normalize twice
             var selectorData = void 0,
-                _source2 = void 0;
+                _source3 = void 0;
             if (response) {
               var _normalizeRelayPayloa2 = require('./normalizeRelayPayload')(_operation2.root, response);
 
-              _source2 = _normalizeRelayPayloa2.source;
+              _source3 = _normalizeRelayPayloa2.source;
 
-              selectorData = lookupSelector(_source2, _operation2.fragment);
+              selectorData = lookupSelector(_source3, _operation2.fragment);
             }
             selectorStoreUpdater && selectorStoreUpdater(selectorStore, selectorData);
-          } else {
+          } else if (optimisticUpdate.storeUpdater) {
             var storeUpdater = optimisticUpdate.storeUpdater;
 
             storeUpdater(store);
+          } else {
+            var _source4 = optimisticUpdate.source,
+                _fieldPayloads2 = optimisticUpdate.fieldPayloads;
+
+            store.publishSource(_source4, _fieldPayloads2);
           }
           _this4._appliedOptimisticUpdates.add(optimisticUpdate);
         });

package/lib/RelayQueryCaching.js

@@ -1,12 +1,9 @@
 /**
  * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
- * @providesModule RelayQueryCaching
  * 
  * @format
  */