diff --git a/packages/relay-runtime/store/RelayExperimentalGraphResponseTransform.js b/packages/relay-runtime/store/RelayExperimentalGraphResponseTransform.js index 1822b5cf918c2..0c91cb7540d28 100644 --- a/packages/relay-runtime/store/RelayExperimentalGraphResponseTransform.js +++ b/packages/relay-runtime/store/RelayExperimentalGraphResponseTransform.js @@ -9,6 +9,9 @@ * @format */ +import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier'; +import type {NormalizationOptions} from './RelayResponseNormalizer'; +import type {IncrementalDataPlaceholder} from './RelayStoreTypes'; import type { DataID, NormalizationField, @@ -22,15 +25,20 @@ import type { } from 'relay-runtime/util/NormalizationNode'; import type {Variables} from 'relay-runtime/util/RelayRuntimeTypes'; +const {getLocalVariables} = require('./RelayConcreteVariables'); +const {createNormalizationSelector} = require('./RelayModernSelector'); const invariant = require('invariant'); const {generateClientID} = require('relay-runtime'); -const defaultGetDataID = require('relay-runtime/store/defaultGetDataID'); const { ROOT_TYPE, TYPENAME_KEY, getStorageKey, } = require('relay-runtime/store/RelayStoreUtils'); const { + CLIENT_EXTENSION, + CONDITION, + DEFER, + FRAGMENT_SPREAD, INLINE_FRAGMENT, LINKED_FIELD, SCALAR_FIELD, @@ -118,24 +126,31 @@ export type GraphModeResponse = Iterable; export function normalizeResponse( response: PayloadData, selector: NormalizationSelector, + options: NormalizationOptions, ): GraphModeResponse { const {node, variables, dataID} = selector; - const normalizer = new GraphModeNormalizer(variables); + const normalizer = new GraphModeNormalizer(variables, options); return normalizer.normalizeResponse(node, dataID, response); } class GraphModeNormalizer { _cacheKeyToStreamID: Map; _sentFields: Map>; + _getDataId: GetDataID; _nextStreamID: number; _getDataID: GetDataID; _variables: Variables; - constructor(variables: Variables) { + _path: Array; + _incrementalPlaceholders: Array; + _actorIdentifier: ?ActorIdentifier; + constructor(variables: Variables, options: NormalizationOptions) { + this._actorIdentifier = options.actorIdentifier; + this._path = options.path ? [...options.path] : []; + this._getDataID = options.getDataID; this._cacheKeyToStreamID = new Map(); this._sentFields = new Map(); this._nextStreamID = 0; this._variables = variables; - this._getDataID = defaultGetDataID; } _getStreamID() { @@ -168,6 +183,15 @@ class GraphModeNormalizer { return getStorageKey(selection, this._variables); } + _getVariableValue(name: string): mixed { + invariant( + this._variables.hasOwnProperty(name), + 'Unexpected undefined variable `%s`.', + name, + ); + return this._variables[name]; + } + *normalizeResponse( node: NormalizationNode, dataID: DataID, @@ -232,6 +256,8 @@ class GraphModeNormalizer { const storageKey = this._getStorageKey(selection); + this._path.push(responseKey); + const fieldValue = yield* this._traverseLinkedField( selection.plural, fieldData, @@ -240,6 +266,8 @@ class GraphModeNormalizer { parentID, ); + this._path.pop(); + // TODO: We could also opt to confirm that this matches the previously // seen value. if (sentFields.has(storageKey)) { @@ -285,6 +313,72 @@ class GraphModeNormalizer { ); break; } + case FRAGMENT_SPREAD: { + const prevVariables = this._variables; + this._variables = getLocalVariables( + this._variables, + selection.fragment.argumentDefinitions, + selection.args, + ); + yield* this._traverseSelections( + selection.fragment, + data, + parentFields, + parentID, + sentFields, + ); + this._variables = prevVariables; + break; + } + case CONDITION: + const conditionValue = Boolean( + this._getVariableValue(selection.condition), + ); + if (conditionValue === selection.passingValue) { + yield* this._traverseSelections( + selection, + data, + parentFields, + parentID, + sentFields, + ); + } + break; + case DEFER: + const isDeferred = + selection.if === null || this._getVariableValue(selection.if); + if (isDeferred === false) { + // If defer is disabled there will be no additional response chunk: + // normalize the data already present. + yield* this._traverseSelections( + selection, + data, + parentFields, + parentID, + sentFields, + ); + } else { + // Otherwise data *for this selection* should not be present: enqueue + // metadata to process the subsequent response chunk. + this._incrementalPlaceholders.push({ + kind: 'defer', + data, + label: selection.label, + path: [...this._path], + selector: createNormalizationSelector( + selection, + parentID, + this._variables, + ), + typeName: this._getObjectType(data), + actorIdentifier: this._actorIdentifier, + }); + } + break; + case CLIENT_EXTENSION: + // Since we are only expecting to handle server responses, we can skip + // over client extensions. + break; default: throw new Error(`Unexpected selection type: ${selection.kind}`); } @@ -311,6 +405,7 @@ class GraphModeNormalizer { const fieldValue = []; for (const [i, itemData] of fieldData.entries()) { + this._path.push(String(i)); const itemValue = yield* this._traverseLinkedField( false, itemData, @@ -319,6 +414,7 @@ class GraphModeNormalizer { parentID, i, ); + this._path.pop(); fieldValue.push(itemValue); } diff --git a/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseHandler-test.js b/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseHandler-test.js index a23b75b1cac1f..1ead4262c3769 100644 --- a/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseHandler-test.js +++ b/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseHandler-test.js @@ -14,6 +14,7 @@ import type {MutableRecordSource} from '../RelayStoreTypes'; import type {GraphQLTaggedNode, PayloadData, Variables} from 'relay-runtime'; +const defaultGetDataID = require('../defaultGetDataID'); const { handleGraphModeResponse, } = require('../RelayExperimentalGraphResponseHandler'); @@ -26,6 +27,11 @@ const {ROOT_ID} = require('../RelayStoreUtils'); const {graphql} = require('relay-runtime'); const {getRequest} = require('relay-runtime/query/GraphQLTag'); +const defaultOptions = { + getDataID: defaultGetDataID, + treatMissingFieldsAsNull: false, +}; + function applyTransform( query: GraphQLTaggedNode, response: PayloadData, @@ -36,7 +42,11 @@ function applyTransform( ROOT_ID, variables, ); - const graphModeResponse = normalizeResponse(response, selector); + const graphModeResponse = normalizeResponse( + response, + selector, + defaultOptions, + ); const recordSource = new RelayRecordSource(); diff --git a/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseTransform-test.js b/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseTransform-test.js index 1c6ce82b23b8c..0ad52666fb84c 100644 --- a/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseTransform-test.js +++ b/packages/relay-runtime/store/__tests__/RelayExperimentalGraphResponseTransform-test.js @@ -15,6 +15,7 @@ import type {GraphModeChunk} from '../RelayExperimentalGraphResponseTransform'; import type {PayloadData, Variables} from 'relay-runtime'; import type {GraphQLTaggedNode} from 'relay-runtime/query/GraphQLTag'; +const defaultGetDataID = require('../defaultGetDataID'); const { normalizeResponse, } = require('../RelayExperimentalGraphResponseTransform'); @@ -25,6 +26,11 @@ const { } = require('relay-runtime/store/RelayModernSelector'); const {ROOT_ID} = require('relay-runtime/store/RelayStoreUtils'); +const defaultOptions = { + getDataID: defaultGetDataID, + treatMissingFieldsAsNull: false, +}; + function applyTransform( query: GraphQLTaggedNode, response: PayloadData, @@ -35,7 +41,7 @@ function applyTransform( ROOT_ID, variables, ); - return Array.from(normalizeResponse(response, selector)); + return Array.from(normalizeResponse(response, selector, defaultOptions)); } test('Basic', () => { @@ -562,3 +568,109 @@ test('Fragment Spread (gets inlined into `InlineFragment`)', () => { ] `); }); + +test('Fragment Spread @no_inline', () => { + graphql` + fragment RelayExperimentalGraphResponseTransformTest_no_inline_user_name on User + @no_inline { + name + } + `; + const query = graphql` + query RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery { + node(id: "10") { + ...RelayExperimentalGraphResponseTransformTest_no_inline_user_name + } + } + `; + const response = { + node: { + __typename: 'User', + name: 'Elizabeth', + id: '10', + }, + }; + + const actual = applyTransform(query, response, {}); + + expect(actual).toMatchInlineSnapshot(` + Array [ + Object { + "$kind": "Record", + "$streamID": 0, + "__id": "10", + "__typename": "User", + "id": "10", + "name": "Elizabeth", + }, + Object { + "$kind": "Record", + "$streamID": 1, + "__id": "client:root", + "__typename": "__Root", + "node(id:\\"10\\")": Object { + "__id": 0, + }, + }, + Object { + "$kind": "Complete", + }, + ] + `); +}); + +test('Traverses when @defer is disabled', () => { + graphql` + fragment RelayExperimentalGraphResponseTransformTest_condition on User { + name + } + `; + const query = graphql` + query RelayExperimentalGraphResponseTransformTestConditionQuery( + $id: ID! + $enableDefer: Boolean! + ) { + node(id: $id) { + ...RelayExperimentalGraphResponseTransformTest_condition + @defer(label: "TestFragment", if: $enableDefer) + } + } + `; + const response = { + node: { + __typename: 'User', + name: 'Elizabeth', + id: '10', + }, + }; + + const actual = applyTransform(query, response, { + id: '1', + enableDefer: false, + }); + + expect(actual).toMatchInlineSnapshot(` + Array [ + Object { + "$kind": "Record", + "$streamID": 0, + "__id": "10", + "__typename": "User", + "id": "10", + "name": "Elizabeth", + }, + Object { + "$kind": "Record", + "$streamID": 1, + "__id": "client:root", + "__typename": "__Root", + "node(id:\\"1\\")": Object { + "__id": 0, + }, + }, + Object { + "$kind": "Complete", + }, + ] + `); +}); diff --git a/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTestConditionQuery.graphql.js b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTestConditionQuery.graphql.js new file mode 100644 index 0000000000000..b4e182cbaec6e --- /dev/null +++ b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTestConditionQuery.graphql.js @@ -0,0 +1,165 @@ +/** + * 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. + * + * @generated SignedSource<<9ecdabfb22458929774ae66b268ba15d>> + * @flow + * @lightSyntaxTransform + * @nogrep + */ + +/* eslint-disable */ + +'use strict'; + +/*:: +import type { ConcreteRequest, Query } from 'relay-runtime'; +type RelayExperimentalGraphResponseTransformTest_condition$fragmentType = any; +export type RelayExperimentalGraphResponseTransformTestConditionQuery$variables = {| + id: string, + enableDefer: boolean, +|}; +export type RelayExperimentalGraphResponseTransformTestConditionQueryVariables = RelayExperimentalGraphResponseTransformTestConditionQuery$variables; +export type RelayExperimentalGraphResponseTransformTestConditionQuery$data = {| + +node: ?{| + +$fragmentSpreads: RelayExperimentalGraphResponseTransformTest_condition$fragmentType, + |}, +|}; +export type RelayExperimentalGraphResponseTransformTestConditionQueryResponse = RelayExperimentalGraphResponseTransformTestConditionQuery$data; +export type RelayExperimentalGraphResponseTransformTestConditionQuery = {| + variables: RelayExperimentalGraphResponseTransformTestConditionQueryVariables, + response: RelayExperimentalGraphResponseTransformTestConditionQuery$data, +|}; +*/ + +var node/*: ConcreteRequest*/ = (function(){ +var v0 = { + "defaultValue": null, + "kind": "LocalArgument", + "name": "enableDefer" +}, +v1 = { + "defaultValue": null, + "kind": "LocalArgument", + "name": "id" +}, +v2 = [ + { + "kind": "Variable", + "name": "id", + "variableName": "id" + } +]; +return { + "fragment": { + "argumentDefinitions": [ + (v0/*: any*/), + (v1/*: any*/) + ], + "kind": "Fragment", + "metadata": null, + "name": "RelayExperimentalGraphResponseTransformTestConditionQuery", + "selections": [ + { + "alias": null, + "args": (v2/*: any*/), + "concreteType": null, + "kind": "LinkedField", + "name": "node", + "plural": false, + "selections": [ + { + "kind": "Defer", + "selections": [ + { + "args": null, + "kind": "FragmentSpread", + "name": "RelayExperimentalGraphResponseTransformTest_condition" + } + ] + } + ], + "storageKey": null + } + ], + "type": "Query", + "abstractKey": null + }, + "kind": "Request", + "operation": { + "argumentDefinitions": [ + (v1/*: any*/), + (v0/*: any*/) + ], + "kind": "Operation", + "name": "RelayExperimentalGraphResponseTransformTestConditionQuery", + "selections": [ + { + "alias": null, + "args": (v2/*: any*/), + "concreteType": null, + "kind": "LinkedField", + "name": "node", + "plural": false, + "selections": [ + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "__typename", + "storageKey": null + }, + { + "if": "enableDefer", + "kind": "Defer", + "label": "RelayExperimentalGraphResponseTransformTestConditionQuery$defer$TestFragment", + "selections": [ + { + "kind": "InlineFragment", + "selections": [ + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "name", + "storageKey": null + } + ], + "type": "User", + "abstractKey": null + } + ] + }, + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "id", + "storageKey": null + } + ], + "storageKey": null + } + ] + }, + "params": { + "cacheID": "75fe5327b6347c4e4e69e590249eabf7", + "id": null, + "metadata": {}, + "name": "RelayExperimentalGraphResponseTransformTestConditionQuery", + "operationKind": "query", + "text": "query RelayExperimentalGraphResponseTransformTestConditionQuery(\n $id: ID!\n $enableDefer: Boolean!\n) {\n node(id: $id) {\n __typename\n ...RelayExperimentalGraphResponseTransformTest_condition @defer(label: \"RelayExperimentalGraphResponseTransformTestConditionQuery$defer$TestFragment\", if: $enableDefer)\n id\n }\n}\n\nfragment RelayExperimentalGraphResponseTransformTest_condition on User {\n name\n}\n" + } +}; +})(); + +if (__DEV__) { + (node/*: any*/).hash = "6d02d262365a960c063af8b116377d2a"; +} + +module.exports = ((node/*: any*/)/*: Query< + RelayExperimentalGraphResponseTransformTestConditionQuery$variables, + RelayExperimentalGraphResponseTransformTestConditionQuery$data, +>*/); diff --git a/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery.graphql.js b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery.graphql.js new file mode 100644 index 0000000000000..2182624f5a7b2 --- /dev/null +++ b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery.graphql.js @@ -0,0 +1,125 @@ +/** + * 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. + * + * @generated SignedSource<> + * @flow + * @lightSyntaxTransform + * @nogrep + */ + +/* eslint-disable */ + +'use strict'; + +/*:: +import type { ConcreteRequest, Query } from 'relay-runtime'; +type RelayExperimentalGraphResponseTransformTest_no_inline_user_name$fragmentType = any; +export type RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery$variables = {||}; +export type RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQueryVariables = RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery$variables; +export type RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery$data = {| + +node: ?{| + +$fragmentSpreads: RelayExperimentalGraphResponseTransformTest_no_inline_user_name$fragmentType, + |}, +|}; +export type RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQueryResponse = RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery$data; +export type RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery = {| + variables: RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQueryVariables, + response: RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery$data, +|}; +*/ + +var node/*: ConcreteRequest*/ = (function(){ +var v0 = [ + { + "kind": "Literal", + "name": "id", + "value": "10" + } +]; +return { + "fragment": { + "argumentDefinitions": [], + "kind": "Fragment", + "metadata": null, + "name": "RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery", + "selections": [ + { + "alias": null, + "args": (v0/*: any*/), + "concreteType": null, + "kind": "LinkedField", + "name": "node", + "plural": false, + "selections": [ + { + "args": null, + "kind": "FragmentSpread", + "name": "RelayExperimentalGraphResponseTransformTest_no_inline_user_name" + } + ], + "storageKey": "node(id:\"10\")" + } + ], + "type": "Query", + "abstractKey": null + }, + "kind": "Request", + "operation": { + "argumentDefinitions": [], + "kind": "Operation", + "name": "RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery", + "selections": [ + { + "alias": null, + "args": (v0/*: any*/), + "concreteType": null, + "kind": "LinkedField", + "name": "node", + "plural": false, + "selections": [ + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "__typename", + "storageKey": null + }, + { + "args": null, + "fragment": require('./RelayExperimentalGraphResponseTransformTest_no_inline_user_name$normalization.graphql'), + "kind": "FragmentSpread" + }, + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "id", + "storageKey": null + } + ], + "storageKey": "node(id:\"10\")" + } + ] + }, + "params": { + "cacheID": "c2be61a649c1c0c603f33ec12b31aeaf", + "id": null, + "metadata": {}, + "name": "RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery", + "operationKind": "query", + "text": "query RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery {\n node(id: \"10\") {\n __typename\n ...RelayExperimentalGraphResponseTransformTest_no_inline_user_name\n id\n }\n}\n\nfragment RelayExperimentalGraphResponseTransformTest_no_inline_user_name on User {\n name\n}\n" + } +}; +})(); + +if (__DEV__) { + (node/*: any*/).hash = "fbfe5e49950cb623a46a3c6e4377ee0c"; +} + +module.exports = ((node/*: any*/)/*: Query< + RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery$variables, + RelayExperimentalGraphResponseTransformTestFragmentSpreadNoInlineQuery$data, +>*/); diff --git a/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_condition.graphql.js b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_condition.graphql.js new file mode 100644 index 0000000000000..f9f1b61129f96 --- /dev/null +++ b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_condition.graphql.js @@ -0,0 +1,59 @@ +/** + * 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. + * + * @generated SignedSource<<7cd4691565c5ce2bb2ae9d764d5eb55d>> + * @flow + * @lightSyntaxTransform + * @nogrep + */ + +/* eslint-disable */ + +'use strict'; + +/*:: +import type { Fragment, ReaderFragment } from 'relay-runtime'; +import type { FragmentType } from "relay-runtime"; +declare export opaque type RelayExperimentalGraphResponseTransformTest_condition$fragmentType: FragmentType; +export type RelayExperimentalGraphResponseTransformTest_condition$ref = RelayExperimentalGraphResponseTransformTest_condition$fragmentType; +export type RelayExperimentalGraphResponseTransformTest_condition$data = {| + +name: ?string, + +$fragmentType: RelayExperimentalGraphResponseTransformTest_condition$fragmentType, +|}; +export type RelayExperimentalGraphResponseTransformTest_condition = RelayExperimentalGraphResponseTransformTest_condition$data; +export type RelayExperimentalGraphResponseTransformTest_condition$key = { + +$data?: RelayExperimentalGraphResponseTransformTest_condition$data, + +$fragmentSpreads: RelayExperimentalGraphResponseTransformTest_condition$fragmentType, + ... +}; +*/ + +var node/*: ReaderFragment*/ = { + "argumentDefinitions": [], + "kind": "Fragment", + "metadata": null, + "name": "RelayExperimentalGraphResponseTransformTest_condition", + "selections": [ + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "name", + "storageKey": null + } + ], + "type": "User", + "abstractKey": null +}; + +if (__DEV__) { + (node/*: any*/).hash = "0a6ec18ee80fb0caf454bf1d2fa621a6"; +} + +module.exports = ((node/*: any*/)/*: Fragment< + RelayExperimentalGraphResponseTransformTest_condition$fragmentType, + RelayExperimentalGraphResponseTransformTest_condition$data, +>*/); diff --git a/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_no_inline_user_name$normalization.graphql.js b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_no_inline_user_name$normalization.graphql.js new file mode 100644 index 0000000000000..f3fa86c10987d --- /dev/null +++ b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_no_inline_user_name$normalization.graphql.js @@ -0,0 +1,41 @@ +/** + * 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. + * + * @generated SignedSource<> + * @flow + * @lightSyntaxTransform + * @nogrep + */ + +/* eslint-disable */ + +'use strict'; + +/*:: +import type { NormalizationSplitOperation } from 'relay-runtime'; + +*/ + +var node/*: NormalizationSplitOperation*/ = { + "kind": "SplitOperation", + "metadata": {}, + "name": "RelayExperimentalGraphResponseTransformTest_no_inline_user_name$normalization", + "selections": [ + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "name", + "storageKey": null + } + ] +}; + +if (__DEV__) { + (node/*: any*/).hash = "91394abbe5b69867a91202783e70a2a3"; +} + +module.exports = node; diff --git a/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_no_inline_user_name.graphql.js b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_no_inline_user_name.graphql.js new file mode 100644 index 0000000000000..81e1e00a1ef6c --- /dev/null +++ b/packages/relay-runtime/store/__tests__/__generated__/RelayExperimentalGraphResponseTransformTest_no_inline_user_name.graphql.js @@ -0,0 +1,59 @@ +/** + * 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. + * + * @generated SignedSource<<5b9b7707038934c7b9454728d57532bf>> + * @flow + * @lightSyntaxTransform + * @nogrep + */ + +/* eslint-disable */ + +'use strict'; + +/*:: +import type { Fragment, ReaderFragment } from 'relay-runtime'; +import type { FragmentType } from "relay-runtime"; +declare export opaque type RelayExperimentalGraphResponseTransformTest_no_inline_user_name$fragmentType: FragmentType; +export type RelayExperimentalGraphResponseTransformTest_no_inline_user_name$ref = RelayExperimentalGraphResponseTransformTest_no_inline_user_name$fragmentType; +export type RelayExperimentalGraphResponseTransformTest_no_inline_user_name$data = {| + +name: ?string, + +$fragmentType: RelayExperimentalGraphResponseTransformTest_no_inline_user_name$fragmentType, +|}; +export type RelayExperimentalGraphResponseTransformTest_no_inline_user_name = RelayExperimentalGraphResponseTransformTest_no_inline_user_name$data; +export type RelayExperimentalGraphResponseTransformTest_no_inline_user_name$key = { + +$data?: RelayExperimentalGraphResponseTransformTest_no_inline_user_name$data, + +$fragmentSpreads: RelayExperimentalGraphResponseTransformTest_no_inline_user_name$fragmentType, + ... +}; +*/ + +var node/*: ReaderFragment*/ = { + "argumentDefinitions": [], + "kind": "Fragment", + "metadata": null, + "name": "RelayExperimentalGraphResponseTransformTest_no_inline_user_name", + "selections": [ + { + "alias": null, + "args": null, + "kind": "ScalarField", + "name": "name", + "storageKey": null + } + ], + "type": "User", + "abstractKey": null +}; + +if (__DEV__) { + (node/*: any*/).hash = "91394abbe5b69867a91202783e70a2a3"; +} + +module.exports = ((node/*: any*/)/*: Fragment< + RelayExperimentalGraphResponseTransformTest_no_inline_user_name$fragmentType, + RelayExperimentalGraphResponseTransformTest_no_inline_user_name$data, +>*/);