relay-runtime 12.0.0 → 13.0.0

package/mutations/readUpdatableQuery_EXPERIMENTAL.js.flow

@@ -0,0 +1,318 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @emails oncall+relay
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {RecordProxy, RecordSourceProxy} from '../store/RelayStoreTypes';
+import type {ReaderLinkedField, ReaderSelection} from '../util/ReaderNode';
+import type {OperationType} from '../util/RelayRuntimeTypes';
+
+const {getRequest} = require('../query/GraphQLTag');
+const {getArgumentValues} = require('../store/RelayStoreUtils');
+
+const nonUpdatableKeys = ['id', '__id', '__typename'];
+
+function readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
+  query: GraphQLTaggedNode,
+  variables: TQuery['variables'],
+  proxy: RecordSourceProxy,
+): TQuery['response'] {
+  // TODO assert that the concrete request is an updatable query
+  const request = getRequest(query);
+
+  const updatableProxy = {};
+  updateProxyFromSelections(
+    updatableProxy,
+    proxy.getRoot(),
+    variables,
+    request.fragment.selections,
+    proxy,
+  );
+  if (__DEV__) {
+    Object.freeze(updatableProxy);
+  }
+  return updatableProxy;
+}
+
+function updateProxyFromSelections<TQuery: OperationType>(
+  mutableUpdatableProxy: TQuery['response'],
+  recordProxy: RecordProxy,
+  queryVariables: TQuery['variables'],
+  selections: $ReadOnlyArray<ReaderSelection>,
+  root: RecordSourceProxy,
+) {
+  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,
+          },
+        );
+        break;
+      case 'ScalarField':
+        const scalarFieldName = selection.alias ?? selection.name;
+        Object.defineProperty(mutableUpdatableProxy, scalarFieldName, {
+          get: function () {
+            const variables = getArgumentValues(
+              selection.args ?? [],
+              queryVariables,
+            );
+            // Flow incorrect assumes that the return value for the get method must match
+            // the set parameter.
+            return (recordProxy.getValue(
+              selection.name,
+              // $FlowFixMe[unclear-type] No good way to type these variables
+              (variables: any),
+              // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+            ): any);
+          },
+          set: nonUpdatableKeys.includes(selection.name)
+            ? undefined
+            : // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+              function (newValue: ?any) {
+                const variables = getArgumentValues(
+                  selection.args ?? [],
+                  queryVariables,
+                );
+                recordProxy.setValue(
+                  newValue,
+                  selection.name,
+                  // $FlowFixMe[unclear-type] No good way to type these variables
+                  (variables: any),
+                );
+              },
+        });
+        break;
+      case 'InlineFragment':
+        if (recordProxy.getType() === selection.type) {
+          updateProxyFromSelections(
+            mutableUpdatableProxy,
+            recordProxy,
+            queryVariables,
+            selection.selections,
+            root,
+          );
+        }
+        break;
+      case 'ClientExtension':
+        updateProxyFromSelections(
+          mutableUpdatableProxy,
+          recordProxy,
+          queryVariables,
+          selection.selections,
+          root,
+        );
+        break;
+      case 'FragmentSpread':
+        // Explicitly ignore
+        break;
+      default:
+        throw new Error(
+          'Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.',
+        );
+    }
+  }
+}
+
+function createSetterForPluralLinkedField<TQuery: OperationType>(
+  selection: ReaderLinkedField,
+  queryVariables: TQuery['variables'],
+  recordProxy: RecordProxy,
+  root: RecordSourceProxy,
+) {
+  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));
+    } else {
+      const recordProxies = newValue.map(item => {
+        if (item == null) {
+          throw new Error(
+            'When assigning an array of items, none of the items should be null or undefined.',
+          );
+        }
+        const {__id} = item;
+        if (__id == null) {
+          throw new Error(
+            'The __id field must be present on each item passed to the setter. This indicates a bug in Relay.',
+          );
+        }
+        const newValueRecord = root.get(__id);
+        if (newValueRecord == null) {
+          throw new Error(
+            `Did not find item with data id ${__id} in the store.`,
+          );
+        }
+        return newValueRecord;
+      });
+      recordProxy.setLinkedRecords(
+        recordProxies,
+        selection.name,
+        // $FlowFixMe[unclear-type] No good way to type these variables
+        (variables: any),
+      );
+    }
+  };
+}
+function createSetterForSingularLinkedField<TQuery: OperationType>(
+  selection: ReaderLinkedField,
+  queryVariables: TQuery['variables'],
+  recordProxy: RecordProxy,
+  root: RecordSourceProxy,
+) {
+  return function set(newValue: ?{__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));
+    } else {
+      const {__id} = newValue;
+      if (__id == null) {
+        throw new Error(
+          'The __id field must be present on the argument. This indicates a bug in Relay.',
+        );
+      }
+      const newValueRecord = root.get(__id);
+      if (newValueRecord == null) {
+        throw new Error(`Did not find item with data id ${__id} in the store.`);
+      }
+      recordProxy.setLinkedRecord(
+        newValueRecord,
+        selection.name,
+        // $FlowFixMe[unclear-type] No good way to type these variables
+        (variables: any),
+      );
+    }
+  };
+}
+
+function createGetterForPluralLinkedField<TQuery: OperationType>(
+  selection: ReaderLinkedField,
+  queryVariables: TQuery['variables'],
+  recordProxy: RecordProxy,
+  root: RecordSourceProxy,
+) {
+  return function () {
+    const variables = getArgumentValues(selection.args ?? [], queryVariables);
+    const linkedRecords = recordProxy.getLinkedRecords(
+      selection.name,
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      (variables: any),
+    );
+    if (linkedRecords != null) {
+      return (linkedRecords.map(linkedRecord => {
+        if (linkedRecord != null) {
+          const updatableProxy = {};
+          updateProxyFromSelections(
+            updatableProxy,
+            linkedRecord,
+            queryVariables,
+            selection.selections,
+            root,
+          );
+          if (__DEV__) {
+            Object.freeze(updatableProxy);
+          }
+          // Flow incorrect assumes that the return value for the get method must match
+          // the set parameter.
+          // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+          return (updatableProxy: any);
+        } else {
+          return linkedRecord;
+        }
+        // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+      }): any);
+    } else {
+      return linkedRecords;
+    }
+  };
+}
+
+function createGetterForSingularLinkedField<TQuery: OperationType>(
+  selection: ReaderLinkedField,
+  queryVariables: TQuery['variables'],
+  recordProxy: RecordProxy,
+  root: RecordSourceProxy,
+) {
+  return function () {
+    const variables = getArgumentValues(selection.args ?? [], queryVariables);
+    const linkedRecord = recordProxy.getLinkedRecord(
+      selection.name,
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      (variables: any),
+    );
+    if (linkedRecord != null) {
+      const updatableProxy = {};
+      updateProxyFromSelections(
+        updatableProxy,
+        linkedRecord,
+        queryVariables,
+        selection.selections,
+        root,
+      );
+      if (__DEV__) {
+        Object.freeze(updatableProxy);
+      }
+      // Flow incorrect assumes that the return value for the get method must match
+      // the set parameter.
+      // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+      return (updatableProxy: any);
+    } else {
+      return linkedRecord;
+    }
+  };
+}
+
+module.exports = {readUpdatableQuery_EXPERIMENTAL};

package/mutations/validateMutation.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -13,31 +13,17 @@
 'use strict';
 
 import type {
-  NormalizationSelection,
   NormalizationField,
+  NormalizationSelection,
 } from '../util/NormalizationNode';
 import type {ConcreteRequest} from '../util/RelayConcreteNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
-type ValidationContext = {|
-  visitedPaths: Set<string>,
-  path: string,
-  variables: Variables,
-  missingDiff: Object,
-  extraDiff: Object,
-  moduleImportPaths: Set<string>,
-|};
-
-const warning = require('warning');
-
-// $FlowFixMe[method-unbinding] added when improving typing for this parameters
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-
 const {
   ACTOR_CHANGE,
-  CONDITION,
   CLIENT_COMPONENT,
   CLIENT_EXTENSION,
+  CONDITION,
   DEFER,
   FLIGHT_FIELD,
   FRAGMENT_SPREAD,
@@ -50,10 +36,26 @@ const {
   STREAM,
   TYPE_DISCRIMINATOR,
 } = require('../util/RelayConcreteNode');
+const warning = require('warning');
+
+type ValidationContext = {|
+  visitedPaths: Set<string>,
+  path: string,
+  variables: Variables,
+  missingDiff: Object,
+  extraDiff: Object,
+  moduleImportPaths: Set<string>,
+|};
+// $FlowFixMe[method-unbinding] added when improving typing for this parameters
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 let validateMutation = () => {};
 if (__DEV__) {
-  const addFieldToDiff = (path: string, diff: Object, isScalar) => {
+  const addFieldToDiff = (
+    path: string,
+    diff: Object,
+    isScalar: void | boolean,
+  ) => {
     let deepLoc = diff;
     path.split('.').forEach((key, index, arr) => {
       if (deepLoc[key] == null) {

package/network/ConvertToExecuteFunction.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -12,10 +12,10 @@
 
 'use strict';
 
-const RelayObservable = require('./RelayObservable');
-
 import type {ExecuteFunction, FetchFunction} from './RelayNetworkTypes';
 
+const RelayObservable = require('./RelayObservable');
+
 /**
  * Converts a FetchFunction into an ExecuteFunction for use by RelayNetwork.
  */

package/network/RelayNetwork.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -12,22 +12,21 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
-const {convertFetch} = require('./ConvertToExecuteFunction');
-
 import type {RequestParameters} from '../util/RelayConcreteNode';
 import type {CacheConfig, Variables} from '../util/RelayRuntimeTypes';
 import type {
   FetchFunction,
   GraphQLResponse,
-  LogRequestInfoFunction,
   INetwork,
+  LogRequestInfoFunction,
   SubscribeFunction,
   UploadableMap,
 } from './RelayNetworkTypes';
 import type RelayObservable from './RelayObservable';
 
+const {convertFetch} = require('./ConvertToExecuteFunction');
+const invariant = require('invariant');
+
 /**
  * Creates an implementation of the `Network` interface defined in
  * `RelayNetworkTypes` given `fetch` and `subscribe` functions.

package/network/RelayNetworkTypes.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.

package/network/RelayObservable.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -223,7 +223,7 @@ class RelayObservable<+T> implements Subscribable<T> {
   do(observer: Observer<T>): RelayObservable<T> {
     return RelayObservable.create(sink => {
       const both = (action: any) =>
-        function() {
+        function () {
           try {
             observer[action] && observer[action].apply(observer, arguments);
           } catch (error) {
@@ -355,13 +355,11 @@ class RelayObservable<+T> implements Subscribable<T> {
         }
       }
 
-      // $FlowFixMe[incompatible-call]
       this.subscribe({
         start,
         next(value) {
           try {
             if (!sink.closed) {
-              // $FlowFixMe[incompatible-call]
               RelayObservable.from(fn(value)).subscribe({
                 start,
                 next: sink.next,

package/network/RelayQueryResponseCache.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -12,15 +12,15 @@
 
 'use strict';
 
-const invariant = require('invariant');
-const stableCopy = require('../util/stableCopy');
-
 import type {Variables} from '../util/RelayRuntimeTypes';
 import type {
   GraphQLResponse,
   GraphQLSingularResponse,
 } from './RelayNetworkTypes';
 
+const stableCopy = require('../util/stableCopy');
+const invariant = require('invariant');
+
 type Response = {
   fetchTime: number,
   payload: GraphQLResponse,

package/network/wrapNetworkWithLogObserver.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -11,19 +11,19 @@
 // flowlint ambiguous-object-type:error
 
 'use strict';
-
-const generateID = require('../util/generateID');
-
 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 {
-  INetwork,
   GraphQLResponse,
+  INetwork,
   UploadableMap,
 } from './RelayNetworkTypes';
 import type RelayObservable from './RelayObservable';
+import type {Subscription} from './RelayObservable';
+
+const generateID = require('../util/generateID');
 
 /**
  * Wraps the network with logging to ensure that network requests are
@@ -46,7 +46,7 @@ function wrapNetworkWithLogObserver(
     ): RelayObservable<GraphQLResponse> {
       const networkRequestId = generateID();
       const logObserver = {
-        start: subscription => {
+        start: (subscription: Subscription) => {
           env.__log({
             name: 'network.start',
             networkRequestId,
@@ -55,14 +55,14 @@ function wrapNetworkWithLogObserver(
             cacheConfig,
           });
         },
-        next: response => {
+        next: (response: GraphQLResponse) => {
           env.__log({
             name: 'network.next',
             networkRequestId,
             response,
           });
         },
-        error: error => {
+        error: (error: Error) => {
           env.__log({
             name: 'network.error',
             networkRequestId,
@@ -82,7 +82,7 @@ function wrapNetworkWithLogObserver(
           });
         },
       };
-      const logRequestInfo = info => {
+      const logRequestInfo = (info: mixed) => {
         env.__log({
           name: 'network.info',
           networkRequestId,

package/package.json

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

package/query/GraphQLTag.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -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,
       ...
     };
 
@@ -39,7 +39,7 @@ export type GraphQLTaggedNode =
  * Runtime function to correspond to the `graphql` tagged template function.
  * All calls to this function should be transformed by the plugin.
  */
-function graphql(strings: Array<string>): GraphQLTaggedNode {
+function graphql(strings: Array<string>): any {
   invariant(
     false,
     'graphql: Unexpected invocation at runtime. Either the Babel transform ' +
@@ -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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -11,7 +11,8 @@
 
 'use strict';
 
-import type {ConcreteRequest, Disposable} from 'relay-runtime';
+import type {ConcreteRequest} from '../util/RelayConcreteNode';
+import type {Disposable} from '../util/RelayRuntimeTypes';
 
 type Callback = (concreteRequest: ConcreteRequest) => void;
 
@@ -60,6 +61,7 @@ class PreloadableQueryRegistry {
   }
 }
 
-const preloadableQueryRegistry: PreloadableQueryRegistry = new PreloadableQueryRegistry();
+const preloadableQueryRegistry: PreloadableQueryRegistry =
+  new PreloadableQueryRegistry();
 
 module.exports = preloadableQueryRegistry;