relay-runtime 0.0.0-main-d7cde3ab → 0.0.0-main-c3ad9027

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-d7cde3ab
+ * Relay v0.0.0-main-c3ad9027
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
  *

package/index.js.flow

@@ -179,8 +179,8 @@ export type {
   NormalizationSplitOperation,
   NormalizationStream,
   NormalizationTypeDiscriminator,
+  NormalizationOperation,
 } from './util/NormalizationNode';
-export type {NormalizationOperation} from './util/NormalizationNode';
 export type {
   ReaderArgument,
   ReaderArgumentDefinition,

package/lib/mutations/RelayRecordSourceProxy.js

@@ -20,6 +20,9 @@ var _require2 = require('../store/RelayStoreUtils'),
     ROOT_ID = _require2.ROOT_ID,
     ROOT_TYPE = _require2.ROOT_TYPE;
 
+var _require3 = require('./readUpdatableQuery_EXPERIMENTAL'),
+    _readUpdatableQuery_EXPERIMENTAL = _require3.readUpdatableQuery_EXPERIMENTAL;
+
 var RelayRecordProxy = require('./RelayRecordProxy');
 
 var invariant = require('invariant');
@@ -132,6 +135,10 @@ var RelayRecordSourceProxy = /*#__PURE__*/function () {
     return this._idsMarkedForInvalidation;
   };
 
+  _proto.readUpdatableQuery_EXPERIMENTAL = function readUpdatableQuery_EXPERIMENTAL(query, variables) {
+    return _readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  };
+
   return RelayRecordSourceProxy;
 }();
 

package/lib/mutations/RelayRecordSourceSelectorProxy.js

@@ -14,6 +14,9 @@ var _require = require('../store/RelayStoreUtils'),
     ROOT_TYPE = _require.ROOT_TYPE,
     getStorageKey = _require.getStorageKey;
 
+var _require2 = require('./readUpdatableQuery_EXPERIMENTAL'),
+    _readUpdatableQuery_EXPERIMENTAL = _require2.readUpdatableQuery_EXPERIMENTAL;
+
 var invariant = require('invariant');
 /**
  * @internal
@@ -92,6 +95,10 @@ var RelayRecordSourceSelectorProxy = /*#__PURE__*/function () {
     this.__recordSource.invalidateStore();
   };
 
+  _proto.readUpdatableQuery_EXPERIMENTAL = function readUpdatableQuery_EXPERIMENTAL(query, variables) {
+    return _readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  };
+
   return RelayRecordSourceSelectorProxy;
 }();
 

package/lib/mutations/readUpdatableQuery_EXPERIMENTAL.js

@@ -0,0 +1,238 @@
+/**
+ * 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.
+ *
+ * 
+ * @emails oncall+relay
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _require = require('../query/GraphQLTag'),
+    getRequest = _require.getRequest;
+
+var _require2 = require('../store/RelayStoreUtils'),
+    getArgumentValues = _require2.getArgumentValues;
+
+var nonUpdatableKeys = ['id', '__id', '__typename'];
+
+function readUpdatableQuery_EXPERIMENTAL(query, variables, proxy) {
+  // TODO assert that the concrete request is an updatable query
+  var request = getRequest(query);
+  var updatableProxy = {};
+  updateProxyFromSelections(updatableProxy, proxy.getRoot(), variables, request.fragment.selections, proxy);
+
+  if (process.env.NODE_ENV !== "production") {
+    Object.freeze(updatableProxy);
+  }
+
+  return updatableProxy;
+}
+
+function updateProxyFromSelections(mutableUpdatableProxy, recordProxy, queryVariables, selections, root) {
+  var _selection$alias, _selection$alias2;
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(selections),
+      _step;
+
+  try {
+    var _loop = function _loop() {
+      var selection = _step.value;
+
+      switch (selection.kind) {
+        case 'LinkedField':
+          // Linked fields are assignable if they contain fragment spreads or
+          // read-only otherwise.
+          var isAssignable = selection.selections.some(function (item) {
+            return item.kind === 'FragmentSpread';
+          });
+          var set = !isAssignable ? undefined : selection.plural ? createSetterForPluralLinkedField(selection, queryVariables, recordProxy, root) : createSetterForSingularLinkedField(selection, queryVariables, recordProxy, root);
+          var get = selection.plural ? createGetterForPluralLinkedField(selection, queryVariables, recordProxy, root) : createGetterForSingularLinkedField(selection, queryVariables, recordProxy, root);
+          Object.defineProperty(mutableUpdatableProxy, (_selection$alias = selection.alias) !== null && _selection$alias !== void 0 ? _selection$alias : selection.name, {
+            get: get,
+            set: set
+          });
+          break;
+
+        case 'ScalarField':
+          var scalarFieldName = (_selection$alias2 = selection.alias) !== null && _selection$alias2 !== void 0 ? _selection$alias2 : selection.name;
+          Object.defineProperty(mutableUpdatableProxy, scalarFieldName, {
+            get: function get() {
+              var _selection$args;
+
+              var variables = getArgumentValues((_selection$args = selection.args) !== null && _selection$args !== void 0 ? _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 // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+              );
+            },
+            set: nonUpdatableKeys.includes(selection.name) ? undefined : // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+            function (newValue) {
+              var _selection$args2;
+
+              var variables = getArgumentValues((_selection$args2 = selection.args) !== null && _selection$args2 !== void 0 ? _selection$args2 : [], queryVariables);
+              recordProxy.setValue(newValue, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+              variables);
+            }
+          });
+          break;
+
+        case 'InlineFragment':
+          if (recordProxy.getType() === selection.type) {
+            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.');
+      }
+    };
+
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function createSetterForPluralLinkedField(selection, queryVariables, recordProxy, root) {
+  return function set(newValue) {
+    var _selection$args3;
+
+    var variables = getArgumentValues((_selection$args3 = selection.args) !== null && _selection$args3 !== void 0 ? _selection$args3 : [], queryVariables);
+
+    if (newValue == null) {
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      recordProxy.setValue(null, selection.name, variables);
+    } else {
+      var recordProxies = newValue.map(function (item) {
+        if (item == null) {
+          throw new Error('When assigning an array of items, none of the items should be null or undefined.');
+        }
+
+        var __id = item.__id;
+
+        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.');
+        }
+
+        var newValueRecord = root.get(__id);
+
+        if (newValueRecord == null) {
+          throw new Error("Did not find item with data id ".concat(__id, " in the store."));
+        }
+
+        return newValueRecord;
+      });
+      recordProxy.setLinkedRecords(recordProxies, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+      variables);
+    }
+  };
+}
+
+function createSetterForSingularLinkedField(selection, queryVariables, recordProxy, root) {
+  return function set(newValue) {
+    var _selection$args4;
+
+    var variables = getArgumentValues((_selection$args4 = selection.args) !== null && _selection$args4 !== void 0 ? _selection$args4 : [], queryVariables);
+
+    if (newValue == null) {
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      recordProxy.setValue(null, selection.name, variables);
+    } else {
+      var __id = newValue.__id;
+
+      if (__id == null) {
+        throw new Error('The __id field must be present on the argument. This indicates a bug in Relay.');
+      }
+
+      var newValueRecord = root.get(__id);
+
+      if (newValueRecord == null) {
+        throw new Error("Did not find item with data id ".concat(__id, " in the store."));
+      }
+
+      recordProxy.setLinkedRecord(newValueRecord, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+      variables);
+    }
+  };
+}
+
+function createGetterForPluralLinkedField(selection, queryVariables, recordProxy, root) {
+  return function () {
+    var _selection$args5;
+
+    var variables = getArgumentValues((_selection$args5 = selection.args) !== null && _selection$args5 !== void 0 ? _selection$args5 : [], queryVariables);
+    var linkedRecords = recordProxy.getLinkedRecords(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+    variables);
+
+    if (linkedRecords != null) {
+      return linkedRecords.map(function (linkedRecord) {
+        if (linkedRecord != null) {
+          var updatableProxy = {};
+          updateProxyFromSelections(updatableProxy, linkedRecord, queryVariables, selection.selections, root);
+
+          if (process.env.NODE_ENV !== "production") {
+            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;
+        } else {
+          return linkedRecord;
+        } // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+
+      });
+    } else {
+      return linkedRecords;
+    }
+  };
+}
+
+function createGetterForSingularLinkedField(selection, queryVariables, recordProxy, root) {
+  return function () {
+    var _selection$args6;
+
+    var variables = getArgumentValues((_selection$args6 = selection.args) !== null && _selection$args6 !== void 0 ? _selection$args6 : [], queryVariables);
+    var linkedRecord = recordProxy.getLinkedRecord(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+    variables);
+
+    if (linkedRecord != null) {
+      var updatableProxy = {};
+      updateProxyFromSelections(updatableProxy, linkedRecord, queryVariables, selection.selections, root);
+
+      if (process.env.NODE_ENV !== "production") {
+        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;
+    } else {
+      return linkedRecord;
+    }
+  };
+}
+
+module.exports = {
+  readUpdatableQuery_EXPERIMENTAL: readUpdatableQuery_EXPERIMENTAL
+};

package/mutations/RelayRecordSourceProxy.js.flow

@@ -13,6 +13,7 @@
 'use strict';
 
 import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
 import type {GetDataID} from '../store/RelayResponseNormalizer';
 import type {
   DataIDSet,
@@ -21,12 +22,15 @@ import type {
   RecordSource,
   RecordSourceProxy,
 } from '../store/RelayStoreTypes';
-import type {DataID} from '../util/RelayRuntimeTypes';
+import type {DataID, OperationType} from '../util/RelayRuntimeTypes';
 import type RelayRecordSourceMutator from './RelayRecordSourceMutator';
 
 const RelayModernRecord = require('../store/RelayModernRecord');
 const {EXISTENT, NONEXISTENT} = require('../store/RelayRecordState');
 const {ROOT_ID, ROOT_TYPE} = require('../store/RelayStoreUtils');
+const {
+  readUpdatableQuery_EXPERIMENTAL,
+} = require('./readUpdatableQuery_EXPERIMENTAL');
 const RelayRecordProxy = require('./RelayRecordProxy');
 const invariant = require('invariant');
 
@@ -158,6 +162,13 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
   getIDsMarkedForInvalidation(): DataIDSet {
     return this._idsMarkedForInvalidation;
   }
+
+  readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
+    query: GraphQLTaggedNode,
+    variables: TQuery['variables'],
+  ): TQuery['response'] {
+    return readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  }
 }
 
 module.exports = RelayRecordSourceProxy;

package/mutations/RelayRecordSourceSelectorProxy.js.flow

@@ -12,6 +12,7 @@
 
 'use strict';
 
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
 import type {
   RecordProxy,
   RecordSourceProxy,
@@ -19,10 +20,13 @@ import type {
   SingularReaderSelector,
 } from '../store/RelayStoreTypes';
 import type {ReaderLinkedField} from '../util/ReaderNode';
-import type {DataID} from '../util/RelayRuntimeTypes';
+import type {DataID, OperationType} from '../util/RelayRuntimeTypes';
 import type RelayRecordSourceMutator from './RelayRecordSourceMutator';
 
 const {ROOT_TYPE, getStorageKey} = require('../store/RelayStoreUtils');
+const {
+  readUpdatableQuery_EXPERIMENTAL,
+} = require('./readUpdatableQuery_EXPERIMENTAL');
 const invariant = require('invariant');
 
 /**
@@ -118,6 +122,13 @@ class RelayRecordSourceSelectorProxy implements RecordSourceSelectorProxy {
   invalidateStore(): void {
     this.__recordSource.invalidateStore();
   }
+
+  readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
+    query: GraphQLTaggedNode,
+    variables: TQuery['variables'],
+  ): TQuery['response'] {
+    return readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  }
 }
 
 module.exports = RelayRecordSourceSelectorProxy;

package/mutations/readUpdatableQuery_EXPERIMENTAL.js.flow

@@ -0,0 +1,309 @@
+/**
+ * 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 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 '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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "0.0.0-main-d7cde3ab",
+  "version": "0.0.0-main-c3ad9027",
   "keywords": [
     "graphql",
     "relay"