relay-runtime 11.0.0 → 13.0.0-rc.0

package/network/RelayQueryResponseCache.js.flow

@@ -12,15 +12,18 @@
 
 'use strict';
 
-const invariant = require('invariant');
-const stableCopy = require('../util/stableCopy');
-
 import type {Variables} from '../util/RelayRuntimeTypes';
-import type {GraphQLSingularResponse} from './RelayNetworkTypes';
+import type {
+  GraphQLResponse,
+  GraphQLSingularResponse,
+} from './RelayNetworkTypes';
+
+const stableCopy = require('../util/stableCopy');
+const invariant = require('invariant');
 
 type Response = {
   fetchTime: number,
-  payload: GraphQLSingularResponse,
+  payload: GraphQLResponse,
   ...
 };
 
@@ -55,7 +58,7 @@ class RelayQueryResponseCache {
     this._responses.clear();
   }
 
-  get(queryID: string, variables: Variables): ?GraphQLSingularResponse {
+  get(queryID: string, variables: Variables): ?GraphQLResponse {
     const cacheKey = getCacheKey(queryID, variables);
     this._responses.forEach((response, key) => {
       if (!isCurrent(response.fetchTime, this._ttl)) {
@@ -63,22 +66,33 @@ class RelayQueryResponseCache {
       }
     });
     const response = this._responses.get(cacheKey);
-    return response != null
-      ? ({
-          ...response.payload,
-          extensions: {
-            ...response.payload.extensions,
-            cacheTimestamp: response.fetchTime,
-          },
-        }: GraphQLSingularResponse)
-      : null;
+    if (response == null) {
+      return null;
+    }
+    if (Array.isArray(response.payload)) {
+      return response.payload.map(
+        payload =>
+          // $FlowFixMe[incompatible-cast]
+          ({
+            ...payload,
+            extensions: {
+              ...payload.extensions,
+              cacheTimestamp: response.fetchTime,
+            },
+          }: GraphQLSingularResponse),
+      );
+    }
+    // $FlowFixMe[incompatible-cast]
+    return ({
+      ...response.payload,
+      extensions: {
+        ...response.payload.extensions,
+        cacheTimestamp: response.fetchTime,
+      },
+    }: GraphQLSingularResponse);
   }
 
-  set(
-    queryID: string,
-    variables: Variables,
-    payload: GraphQLSingularResponse,
-  ): void {
+  set(queryID: string, variables: Variables, payload: GraphQLResponse): void {
     const fetchTime = Date.now();
     const cacheKey = getCacheKey(queryID, variables);
     this._responses.delete(cacheKey); // deletion resets key ordering

package/network/wrapNetworkWithLogObserver.js.flow

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+import type {Subscription} from './RelayObservable';
+
+import type ActorSpecificEnvironment from '../multi-actor-environment/ActorSpecificEnvironment';
+import type RelayModernEnvironment from '../store/RelayModernEnvironment';
+import type {RequestParameters} from '../util/RelayConcreteNode';
+import type {CacheConfig, Variables} from '../util/RelayRuntimeTypes';
+import type {
+  GraphQLResponse,
+  INetwork,
+  UploadableMap,
+} from './RelayNetworkTypes';
+import type RelayObservable from './RelayObservable';
+
+const generateID = require('../util/generateID');
+
+/**
+ * Wraps the network with logging to ensure that network requests are
+ * always logged. Relying on each network callsite to be wrapped is
+ * untenable and will eventually lead to holes in the logging.
+ * NOTE: This function takes an environment instance, because Relay
+ * devtools will mutate the `env.__log` method, and the devtools rely
+ * on it to receive network events.
+ */
+function wrapNetworkWithLogObserver(
+  env: RelayModernEnvironment | ActorSpecificEnvironment,
+  network: INetwork,
+): INetwork {
+  return {
+    execute(
+      params: RequestParameters,
+      variables: Variables,
+      cacheConfig: CacheConfig,
+      uploadables?: ?UploadableMap,
+    ): RelayObservable<GraphQLResponse> {
+      const networkRequestId = generateID();
+      const logObserver = {
+        start: (subscription: Subscription) => {
+          env.__log({
+            name: 'network.start',
+            networkRequestId,
+            params,
+            variables,
+            cacheConfig,
+          });
+        },
+        next: (response: GraphQLResponse) => {
+          env.__log({
+            name: 'network.next',
+            networkRequestId,
+            response,
+          });
+        },
+        error: (error: Error) => {
+          env.__log({
+            name: 'network.error',
+            networkRequestId,
+            error,
+          });
+        },
+        complete: () => {
+          env.__log({
+            name: 'network.complete',
+            networkRequestId,
+          });
+        },
+        unsubscribe: () => {
+          env.__log({
+            name: 'network.unsubscribe',
+            networkRequestId,
+          });
+        },
+      };
+      const logRequestInfo = (info: mixed) => {
+        env.__log({
+          name: 'network.info',
+          networkRequestId,
+          info,
+        });
+      };
+      return network
+        .execute(params, variables, cacheConfig, uploadables, logRequestInfo)
+        .do(logObserver);
+    },
+  };
+}
+
+module.exports = wrapNetworkWithLogObserver;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "11.0.0",
+  "version": "13.0.0-rc.0",
   "keywords": [
     "graphql",
     "relay"
@@ -12,7 +12,8 @@
   "repository": "facebook/relay",
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "fbjs": "^3.0.0"
+    "fbjs": "^3.0.0",
+    "invariant": "^2.2.4"
   },
   "directories": {
     "": "./"

package/query/GraphQLTag.js.flow

@@ -12,26 +12,26 @@
 
 'use strict';
 
-const RelayConcreteNode = require('../util/RelayConcreteNode');
-
-const invariant = require('invariant');
-const warning = require('warning');
-
 import type {
   ReaderFragment,
-  ReaderRefetchableFragment,
-  ReaderPaginationFragment,
   ReaderInlineDataFragment,
+  ReaderPaginationFragment,
+  ReaderRefetchableFragment,
 } from '../util/ReaderNode';
 import type {ConcreteRequest} from '../util/RelayConcreteNode';
 
+const RelayConcreteNode = require('../util/RelayConcreteNode');
+const invariant = require('invariant');
+const warning = require('warning');
+
 // The type of a graphql`...` tagged template expression.
 export type GraphQLTaggedNode =
   | ReaderFragment
+  | ReaderInlineDataFragment
   | ConcreteRequest
   | {
       // This is this case when we `require()` a generated ES6 module
-      default: ReaderFragment | ConcreteRequest,
+      default: ReaderFragment | ReaderInlineDataFragment | ConcreteRequest,
       ...
     };
 
@@ -51,7 +51,7 @@ function graphql(strings: Array<string>): GraphQLTaggedNode {
 
 function getNode(
   taggedNode: GraphQLTaggedNode,
-): ReaderFragment | ConcreteRequest {
+): ReaderFragment | ReaderInlineDataFragment | ConcreteRequest {
   let node = taggedNode;
   if (typeof node === 'function') {
     node = (node(): ReaderFragment | ConcreteRequest);

package/query/PreloadableQueryRegistry.js.flow

@@ -60,6 +60,7 @@ class PreloadableQueryRegistry {
   }
 }
 
-const preloadableQueryRegistry: PreloadableQueryRegistry = new PreloadableQueryRegistry();
+const preloadableQueryRegistry: PreloadableQueryRegistry =
+  new PreloadableQueryRegistry();
 
 module.exports = preloadableQueryRegistry;

package/query/fetchQuery.js.flow

@@ -13,17 +13,6 @@
 
 'use strict';
 
-const RelayObservable = require('../network/RelayObservable');
-
-const fetchQueryInternal = require('./fetchQueryInternal');
-const invariant = require('invariant');
-const reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
-
-const {
-  createOperationDescriptor,
-} = require('../store/RelayModernOperationDescriptor');
-const {getRequest} = require('./GraphQLTag');
-
 import type {
   CacheConfig,
   FetchQueryFetchPolicy,
@@ -35,6 +24,15 @@ import type {
   VariablesOf,
 } from 'relay-runtime';
 
+const RelayObservable = require('../network/RelayObservable');
+const {
+  createOperationDescriptor,
+} = require('../store/RelayModernOperationDescriptor');
+const reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
+const fetchQueryInternal = require('./fetchQueryInternal');
+const {getRequest} = require('./GraphQLTag');
+const invariant = require('invariant');
+
 /**
  * Fetches the given query and variables on the provided environment,
  * and de-dupes identical in-flight requests.
@@ -120,7 +118,7 @@ function fetchQuery<TQuery: OperationType>(
     fetchPolicy?: FetchQueryFetchPolicy,
     networkCacheConfig?: CacheConfig,
   |}>,
-): RelayObservable<$ElementType<TQuery, 'response'>> {
+): RelayObservable<TQuery['response']> {
   const queryNode = getRequest(query);
   invariant(
     queryNode.params.operationKind === 'query',
@@ -165,7 +163,7 @@ function fetchQuery<TQuery: OperationType>(
 function getNetworkObservable<TQuery: OperationType>(
   environment: IEnvironment,
   operation: OperationDescriptor,
-): RelayObservable<$ElementType<TQuery, 'response'>> {
+): RelayObservable<TQuery['response']> {
   return fetchQueryInternal
     .fetchQuery(environment, operation)
     .map(() => environment.lookup(operation.fragment));

package/query/fetchQueryInternal.js.flow

@@ -12,11 +12,6 @@
 
 'use strict';
 
-const Observable = require('../network/RelayObservable');
-const RelayReplaySubject = require('../util/RelayReplaySubject');
-
-const invariant = require('invariant');
-
 import type {GraphQLResponse} from '../network/RelayNetworkTypes';
 import type {Subscription} from '../network/RelayObservable';
 import type {
@@ -26,6 +21,10 @@ import type {
 } from '../store/RelayStoreTypes';
 import type {RequestIdentifier} from '../util/getRequestIdentifier';
 
+const Observable = require('../network/RelayObservable');
+const RelayReplaySubject = require('../util/RelayReplaySubject');
+const invariant = require('invariant');
+
 type RequestCacheEntry = {|
   +identifier: RequestIdentifier,
   +subject: RelayReplaySubject<GraphQLResponse>,
@@ -307,10 +306,8 @@ function getObservableForActiveRequest(
 function getRequestCache(
   environment: IEnvironment,
 ): Map<RequestIdentifier, RequestCacheEntry> {
-  const cached: ?Map<
-    RequestIdentifier,
-    RequestCacheEntry,
-  > = requestCachesByEnvironment.get(environment);
+  const cached: ?Map<RequestIdentifier, RequestCacheEntry> =
+    requestCachesByEnvironment.get(environment);
   if (cached != null) {
     return cached;
   }

package/query/fetchQuery_DEPRECATED.js.flow

@@ -12,15 +12,15 @@
 
 'use strict';
 
+import type {IEnvironment} from '../store/RelayStoreTypes';
+import type {CacheConfig, OperationType} from '../util/RelayRuntimeTypes';
+import type {GraphQLTaggedNode} from './GraphQLTag';
+
 const {
   createOperationDescriptor,
 } = require('../store/RelayModernOperationDescriptor');
 const {getRequest} = require('./GraphQLTag');
 
-import type {IEnvironment} from '../store/RelayStoreTypes';
-import type {CacheConfig, OperationType} from '../util/RelayRuntimeTypes';
-import type {GraphQLTaggedNode} from './GraphQLTag';
-
 /**
  * A helper function to fetch the results of a query. Note that results for
  * fragment spreads are masked: fields must be explicitly listed in the query in
@@ -30,9 +30,9 @@ import type {GraphQLTaggedNode} from './GraphQLTag';
 function fetchQuery_DEPRECATED<T: OperationType>(
   environment: IEnvironment,
   taggedNode: GraphQLTaggedNode,
-  variables: $PropertyType<T, 'variables'>,
+  variables: T['variables'],
   cacheConfig?: ?CacheConfig,
-): Promise<$PropertyType<T, 'response'>> {
+): Promise<T['response']> {
   const query = getRequest(taggedNode);
   if (query.params.operationKind !== 'query') {
     throw new Error('fetchQuery: Expected query operation');