relay-runtime 13.0.0 → 13.1.0

package/mutations/commitMutation.js.flow

@@ -37,32 +37,15 @@ const validateMutation = require('./validateMutation');
 const invariant = require('invariant');
 const warning = require('warning');
 
-export type DEPRECATED_MutationConfig<TMutationResponse> = {|
-  configs?: Array<DeclarativeMutationConfig>,
-  cacheConfig?: CacheConfig,
-  mutation: GraphQLTaggedNode,
-  variables: Variables,
-  uploadables?: UploadableMap,
-  onCompleted?: ?(
-    response: TMutationResponse,
-    errors: ?Array<PayloadError>,
-  ) => void,
-  onError?: ?(error: Error) => void,
-  onUnsubscribe?: ?() => void,
-  optimisticUpdater?: ?SelectorStoreUpdater<TMutationResponse>,
-  optimisticResponse?: Object,
-  updater?: ?SelectorStoreUpdater<TMutationResponse>,
-|};
-
 export type MutationConfig<TMutation: MutationParameters> = {|
-  configs?: Array<DeclarativeMutationConfig>,
   cacheConfig?: CacheConfig,
+  configs?: Array<DeclarativeMutationConfig>,
   mutation: GraphQLTaggedNode,
-  onError?: ?(error: Error) => void,
   onCompleted?: ?(
     response: TMutation['response'],
     errors: ?Array<PayloadError>,
   ) => void,
+  onError?: ?(error: Error) => void,
   onNext?: ?() => void,
   onUnsubscribe?: ?() => void,
   optimisticResponse?: {
@@ -76,6 +59,12 @@ export type MutationConfig<TMutation: MutationParameters> = {|
   variables: TMutation['variables'],
 |};
 
+export type DEPRECATED_MutationConfig<TMutationResponse> = MutationConfig<{|
+  response: TMutationResponse,
+  rawResponse: any,
+  variables: Variables,
+|}>;
+
 /**
  * Higher-level helper function to execute a mutation against a specific
  * environment.

package/mutations/readUpdatableQuery_EXPERIMENTAL.js.flow

@@ -21,7 +21,7 @@ import type {OperationType} from '../util/RelayRuntimeTypes';
 const {getRequest} = require('../query/GraphQLTag');
 const {getArgumentValues} = require('../store/RelayStoreUtils');
 
-const nonUpdatableKeys = ['id', '__id', '__typename'];
+const nonUpdatableKeys = ['id', '__id', '__typename', 'js'];
 
 function readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
   query: GraphQLTaggedNode,
@@ -55,50 +55,46 @@ function updateProxyFromSelections<TQuery: OperationType>(
   for (const selection of selections) {
     switch (selection.kind) {
       case 'LinkedField':
-        // Linked fields are assignable if they contain fragment spreads or
-        // read-only otherwise.
-        const isAssignable = selection.selections.some(
-          item => item.kind === 'FragmentSpread',
-        );
-
-        const set = !isAssignable
-          ? undefined
-          : selection.plural
-          ? createSetterForPluralLinkedField(
-              selection,
-              queryVariables,
-              recordProxy,
-              root,
-            )
-          : createSetterForSingularLinkedField(
-              selection,
-              queryVariables,
-              recordProxy,
-              root,
-            );
-
-        const get = selection.plural
-          ? createGetterForPluralLinkedField(
-              selection,
-              queryVariables,
-              recordProxy,
-              root,
-            )
-          : createGetterForSingularLinkedField(
-              selection,
-              queryVariables,
-              recordProxy,
-              root,
-            );
-
-        Object.defineProperty(
-          mutableUpdatableProxy,
-          selection.alias ?? selection.name,
-          {
-            get,
-            set,
-          },
-        );
+        if (selection.plural) {
+          Object.defineProperty(
+            mutableUpdatableProxy,
+            selection.alias ?? selection.name,
+            {
+              // $FlowFixMe[incompatible-call] these getters and setters have different types on purpose
+              get: createGetterForPluralLinkedField(
+                selection,
+                queryVariables,
+                recordProxy,
+                root,
+              ),
+              set: createSetterForPluralLinkedField(
+                selection,
+                queryVariables,
+                recordProxy,
+                root,
+              ),
+            },
+          );
+        } else {
+          Object.defineProperty(
+            mutableUpdatableProxy,
+            selection.alias ?? selection.name,
+            {
+              get: createGetterForSingularLinkedField(
+                selection,
+                queryVariables,
+                recordProxy,
+                root,
+              ),
+              set: createSetterForSingularLinkedField(
+                selection,
+                queryVariables,
+                recordProxy,
+                root,
+              ),
+            },
+          );
+        }
         break;
       case 'ScalarField':
         const scalarFieldName = selection.alias ?? selection.name;
@@ -171,11 +167,12 @@ function createSetterForPluralLinkedField<TQuery: OperationType>(
   recordProxy: RecordProxy,
   root: RecordSourceProxy,
 ) {
-  return function set(newValue: ?$ReadOnlyArray<{__id: string, ...}>) {
+  return function set(newValue: $ReadOnlyArray<{__id: string, ...}>) {
     const variables = getArgumentValues(selection.args ?? [], queryVariables);
     if (newValue == null) {
-      // $FlowFixMe[unclear-type] No good way to type these variables
-      recordProxy.setValue(null, selection.name, (variables: any));
+      throw new Error(
+        'Do not assign null to plural linked fields; assign an empty array instead.',
+      );
     } else {
       const recordProxies = newValue.map(item => {
         if (item == null) {
@@ -206,6 +203,7 @@ function createSetterForPluralLinkedField<TQuery: OperationType>(
     }
   };
 }
+
 function createSetterForSingularLinkedField<TQuery: OperationType>(
   selection: ReaderLinkedField,
   queryVariables: TQuery['variables'],
@@ -216,7 +214,7 @@ function createSetterForSingularLinkedField<TQuery: OperationType>(
     const variables = getArgumentValues(selection.args ?? [], queryVariables);
     if (newValue == null) {
       // $FlowFixMe[unclear-type] No good way to type these variables
-      recordProxy.setValue(null, selection.name, (variables: any));
+      recordProxy.setValue(newValue, selection.name, (variables: any));
     } else {
       const {__id} = newValue;
       if (__id == null) {

package/mutations/validateMutation.js.flow

@@ -141,6 +141,7 @@ if (__DEV__) {
       case INLINE_FRAGMENT:
         const type = selection.type;
         const isConcreteType = selection.abstractKey == null;
+        validateAbstractKey(context, selection.abstractKey);
         selection.selections.forEach(subselection => {
           if (isConcreteType && optimisticResponse.__typename !== type) {
             return;
@@ -155,11 +156,12 @@ if (__DEV__) {
         return;
       case MODULE_IMPORT:
         return validateModuleImport(context);
+      case TYPE_DISCRIMINATOR:
+        return validateAbstractKey(context, selection.abstractKey);
       case LINKED_HANDLE:
       case SCALAR_HANDLE:
       case DEFER:
-      case STREAM:
-      case TYPE_DISCRIMINATOR: {
+      case STREAM: {
         // TODO(T35864292) - Add missing validations for these types
         return;
       }
@@ -173,6 +175,16 @@ if (__DEV__) {
     context.moduleImportPaths.add(context.path);
   };
 
+  const validateAbstractKey = (
+    context: ValidationContext,
+    abstractKey: ?string,
+  ) => {
+    if (abstractKey != null) {
+      const path = `${context.path}.${abstractKey}`;
+      context.visitedPaths.add(path);
+    }
+  };
+
   const validateField = (
     optimisticResponse: Object,
     field: NormalizationField,

package/network/RelayNetwork.js.flow

@@ -24,6 +24,7 @@ import type {
 } from './RelayNetworkTypes';
 import type RelayObservable from './RelayObservable';
 
+const withProvidedVariables = require('../util/withProvidedVariables');
 const {convertFetch} = require('./ConvertToExecuteFunction');
 const invariant = require('invariant');
 
@@ -45,6 +46,10 @@ function create(
     uploadables?: ?UploadableMap,
     logRequestInfo: ?LogRequestInfoFunction,
   ): RelayObservable<GraphQLResponse> {
+    const operationVariables = withProvidedVariables(
+      variables,
+      request.providedVariables,
+    );
     if (request.operationKind === 'subscription') {
       invariant(
         subscribe,
@@ -56,7 +61,7 @@ function create(
         !uploadables,
         'RelayNetwork: Cannot provide uploadables while subscribing.',
       );
-      return subscribe(request, variables, cacheConfig);
+      return subscribe(request, operationVariables, cacheConfig);
     }
 
     const pollInterval = cacheConfig.poll;
@@ -65,12 +70,14 @@ function create(
         !uploadables,
         'RelayNetwork: Cannot provide uploadables while polling.',
       );
-      return observeFetch(request, variables, {force: true}).poll(pollInterval);
+      return observeFetch(request, operationVariables, {force: true}).poll(
+        pollInterval,
+      );
     }
 
     return observeFetch(
       request,
-      variables,
+      operationVariables,
       cacheConfig,
       uploadables,
       logRequestInfo,

package/network/RelayNetworkTypes.js.flow

@@ -26,7 +26,7 @@ export interface INetwork {
 
 export type LogRequestInfoFunction = mixed => void;
 
-export type PayloadData = interface {[key: string]: mixed};
+export type PayloadData = {[key: string]: mixed};
 
 export type PayloadError = interface {
   message: string,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "13.0.0",
+  "version": "13.1.0",
   "keywords": [
     "graphql",
     "relay"
@@ -9,7 +9,11 @@
   "license": "MIT",
   "homepage": "https://relay.dev",
   "bugs": "https://github.com/facebook/relay/issues",
-  "repository": "facebook/relay",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/relay.git",
+    "directory": "packages/relay-runtime"
+  },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
     "fbjs": "^3.0.2",

package/query/fetchQuery.js.flow

@@ -22,9 +22,9 @@ import type {
   CacheConfig,
   FetchQueryFetchPolicy,
   OperationType,
-  VariablesOf,
+  Query,
+  Variables,
 } from '../util/RelayRuntimeTypes';
-import type {GraphQLTaggedNode} from './GraphQLTag';
 
 const RelayObservable = require('../network/RelayObservable');
 const {
@@ -112,15 +112,15 @@ const invariant = require('invariant');
  * ```
  * NOTE: When using .toPromise(), the request cannot be cancelled.
  */
-function fetchQuery<TQuery: OperationType>(
+function fetchQuery<TVariables: Variables, TData, TRawResponse>(
   environment: IEnvironment,
-  query: GraphQLTaggedNode,
-  variables: VariablesOf<TQuery>,
+  query: Query<TVariables, TData, TRawResponse>,
+  variables: TVariables,
   options?: $ReadOnly<{|
     fetchPolicy?: FetchQueryFetchPolicy,
     networkCacheConfig?: CacheConfig,
   |}>,
-): RelayObservable<TQuery['response']> {
+): RelayObservable<TData> {
   const queryNode = getRequest(query);
   invariant(
     queryNode.params.operationKind === 'query',
@@ -137,10 +137,12 @@ function fetchQuery<TQuery: OperationType>(
   );
   const fetchPolicy = options?.fetchPolicy ?? 'network-only';
 
-  function readData(snapshot: Snapshot) {
+  function readData(snapshot: Snapshot): TData {
     if (snapshot.missingRequiredFields != null) {
       reportMissingRequiredFields(environment, snapshot.missingRequiredFields);
     }
+    /* $FlowFixMe[incompatible-return] we assume readData returns the right
+     * data just having written it from network or checked availability. */
     return snapshot.data;
   }