relay-runtime 8.0.0 → 10.0.1

package/network/RelayQueryResponseCache.js.flow

@@ -0,0 +1,111 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+const stableCopy = require('../util/stableCopy');
+
+import type {Variables} from '../util/RelayRuntimeTypes';
+import type {GraphQLSingularResponse} from './RelayNetworkTypes';
+
+type Response = {
+  fetchTime: number,
+  payload: GraphQLSingularResponse,
+  ...
+};
+
+/**
+ * A cache for storing query responses, featuring:
+ * - `get` with TTL
+ * - cache size limiting, with least-recently *updated* entries purged first
+ */
+class RelayQueryResponseCache {
+  _responses: Map<string, Response>;
+  _size: number;
+  _ttl: number;
+
+  constructor({size, ttl}: {size: number, ttl: number, ...}) {
+    invariant(
+      size > 0,
+      'RelayQueryResponseCache: Expected the max cache size to be > 0, got ' +
+        '`%s`.',
+      size,
+    );
+    invariant(
+      ttl > 0,
+      'RelayQueryResponseCache: Expected the max ttl to be > 0, got `%s`.',
+      ttl,
+    );
+    this._responses = new Map();
+    this._size = size;
+    this._ttl = ttl;
+  }
+
+  clear(): void {
+    this._responses.clear();
+  }
+
+  get(queryID: string, variables: Variables): ?GraphQLSingularResponse {
+    const cacheKey = getCacheKey(queryID, variables);
+    this._responses.forEach((response, key) => {
+      if (!isCurrent(response.fetchTime, this._ttl)) {
+        this._responses.delete(key);
+      }
+    });
+    const response = this._responses.get(cacheKey);
+    return response != null
+      ? ({
+          ...response.payload,
+          extensions: {
+            ...response.payload.extensions,
+            cacheTimestamp: response.fetchTime,
+          },
+        }: GraphQLSingularResponse)
+      : null;
+  }
+
+  set(
+    queryID: string,
+    variables: Variables,
+    payload: GraphQLSingularResponse,
+  ): void {
+    const fetchTime = Date.now();
+    const cacheKey = getCacheKey(queryID, variables);
+    this._responses.delete(cacheKey); // deletion resets key ordering
+    this._responses.set(cacheKey, {
+      fetchTime,
+      payload,
+    });
+    // Purge least-recently updated key when max size reached
+    if (this._responses.size > this._size) {
+      const firstKey = this._responses.keys().next();
+      if (!firstKey.done) {
+        this._responses.delete(firstKey.value);
+      }
+    }
+  }
+}
+
+function getCacheKey(queryID: string, variables: Variables): string {
+  return JSON.stringify(stableCopy({queryID, variables}));
+}
+
+/**
+ * Determine whether a response fetched at `fetchTime` is still valid given
+ * some `ttl`.
+ */
+function isCurrent(fetchTime: number, ttl: number): boolean {
+  return fetchTime + ttl >= Date.now();
+}
+
+module.exports = RelayQueryResponseCache;

package/package.json

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

package/query/GraphQLTag.js.flow

@@ -0,0 +1,166 @@
+/**
+ * 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';
+
+const RelayConcreteNode = require('../util/RelayConcreteNode');
+
+const invariant = require('invariant');
+const warning = require('warning');
+
+import type {
+  ReaderFragment,
+  ReaderRefetchableFragment,
+  ReaderPaginationFragment,
+  ReaderInlineDataFragment,
+} from '../util/ReaderNode';
+import type {ConcreteRequest} from '../util/RelayConcreteNode';
+
+// The type of a graphql`...` tagged template expression.
+export type GraphQLTaggedNode =
+  | ReaderFragment
+  | ConcreteRequest
+  | {
+      // This is this case when we `require()` a generated ES6 module
+      default: ReaderFragment | ConcreteRequest,
+      ...
+    };
+
+/**
+ * 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 {
+  invariant(
+    false,
+    'graphql: Unexpected invocation at runtime. Either the Babel transform ' +
+      'was not set up, or it failed to identify this call site. Make sure it ' +
+      'is being used verbatim as `graphql`.',
+  );
+}
+
+function getNode(
+  taggedNode: GraphQLTaggedNode,
+): ReaderFragment | ConcreteRequest {
+  let node = taggedNode;
+  if (typeof node === 'function') {
+    node = (node(): ReaderFragment | ConcreteRequest);
+    warning(
+      false,
+      'RelayGraphQLTag: node `%s` unexpectedly wrapped in a function.',
+      node.kind === 'Fragment' ? node.name : node.operation.name,
+    );
+  } else if (node.default) {
+    // Support for languages that work (best) with ES6 modules, such as TypeScript.
+    node = node.default;
+  }
+  return node;
+}
+
+function isFragment(node: GraphQLTaggedNode): boolean {
+  const fragment = getNode(node);
+  return (
+    typeof fragment === 'object' &&
+    fragment !== null &&
+    fragment.kind === RelayConcreteNode.FRAGMENT
+  );
+}
+
+function isRequest(node: GraphQLTaggedNode): boolean {
+  const request = getNode(node);
+  return (
+    typeof request === 'object' &&
+    request !== null &&
+    request.kind === RelayConcreteNode.REQUEST
+  );
+}
+
+function isInlineDataFragment(node: GraphQLTaggedNode): boolean {
+  const fragment = getNode(node);
+  return (
+    typeof fragment === 'object' &&
+    fragment !== null &&
+    fragment.kind === RelayConcreteNode.INLINE_DATA_FRAGMENT
+  );
+}
+
+function getFragment(taggedNode: GraphQLTaggedNode): ReaderFragment {
+  const fragment = getNode(taggedNode);
+  invariant(
+    isFragment(fragment),
+    'GraphQLTag: Expected a fragment, got `%s`.',
+    JSON.stringify(fragment),
+  );
+  return (fragment: any);
+}
+
+function getPaginationFragment(
+  taggedNode: GraphQLTaggedNode,
+): ReaderPaginationFragment | null {
+  const fragment = getFragment(taggedNode);
+  const refetch = fragment.metadata?.refetch;
+  const connection = refetch?.connection;
+  if (
+    refetch === null ||
+    typeof refetch !== 'object' ||
+    connection === null ||
+    typeof connection !== 'object'
+  ) {
+    return null;
+  }
+  return (fragment: any);
+}
+
+function getRefetchableFragment(
+  taggedNode: GraphQLTaggedNode,
+): ReaderRefetchableFragment | null {
+  const fragment = getFragment(taggedNode);
+  const refetch = fragment.metadata?.refetch;
+  if (refetch === null || typeof refetch !== 'object') {
+    return null;
+  }
+  return (fragment: any);
+}
+
+function getRequest(taggedNode: GraphQLTaggedNode): ConcreteRequest {
+  const request = getNode(taggedNode);
+  invariant(
+    isRequest(request),
+    'GraphQLTag: Expected a request, got `%s`.',
+    JSON.stringify(request),
+  );
+  return (request: any);
+}
+
+function getInlineDataFragment(
+  taggedNode: GraphQLTaggedNode,
+): ReaderInlineDataFragment {
+  const fragment = getNode(taggedNode);
+  invariant(
+    isInlineDataFragment(fragment),
+    'GraphQLTag: Expected an inline data fragment, got `%s`.',
+    JSON.stringify(fragment),
+  );
+  return (fragment: any);
+}
+
+module.exports = {
+  getFragment,
+  getPaginationFragment,
+  getRefetchableFragment,
+  getRequest,
+  getInlineDataFragment,
+  graphql,
+  isFragment,
+  isRequest,
+  isInlineDataFragment,
+};

package/query/PreloadableQueryRegistry.js.flow

@@ -0,0 +1,65 @@
+/**
+ * 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
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {ConcreteRequest, Disposable} from 'relay-runtime';
+
+type Callback = (concreteRequest: ConcreteRequest) => void;
+
+class PreloadableQueryRegistry {
+  _preloadableQueries: Map<string, ConcreteRequest>;
+  _callbacks: Map<string, Set<Callback>>;
+  constructor() {
+    this._preloadableQueries = new Map();
+    this._callbacks = new Map();
+  }
+
+  set(key: string, value: ConcreteRequest) {
+    this._preloadableQueries.set(key, value);
+    const callbacks = this._callbacks.get(key);
+    if (callbacks != null) {
+      callbacks.forEach(cb => {
+        try {
+          cb(value);
+        } catch (e) {
+          // We do *not* want to throw in this tick, as this callback is executed
+          // while a query is required for the very first time.
+          setTimeout(() => {
+            throw e;
+          }, 0);
+        }
+      });
+    }
+  }
+
+  get(key: string): ?ConcreteRequest {
+    return this._preloadableQueries.get(key);
+  }
+
+  onLoad(key: string, callback: Callback): Disposable {
+    const callbacks = this._callbacks.get(key) ?? new Set();
+    callbacks.add(callback);
+    const dispose = () => {
+      callbacks.delete(callback);
+    };
+    this._callbacks.set(key, callbacks);
+    return {dispose};
+  }
+
+  clear() {
+    this._preloadableQueries.clear();
+  }
+}
+
+const preloadableQueryRegistry: PreloadableQueryRegistry = new PreloadableQueryRegistry();
+
+module.exports = preloadableQueryRegistry;

package/query/fetchQuery.js.flow

@@ -0,0 +1,47 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+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
+ * order to be accessible in the result object.
+ */
+
+function fetchQuery<T: OperationType>(
+  environment: IEnvironment,
+  taggedNode: GraphQLTaggedNode,
+  variables: $PropertyType<T, 'variables'>,
+  cacheConfig?: ?CacheConfig,
+): Promise<$PropertyType<T, 'response'>> {
+  const query = getRequest(taggedNode);
+  if (query.params.operationKind !== 'query') {
+    throw new Error('fetchQuery: Expected query operation');
+  }
+  const operation = createOperationDescriptor(query, variables);
+  return environment
+    .execute({operation, cacheConfig})
+    .map(() => environment.lookup(operation.fragment).data)
+    .toPromise();
+}
+
+module.exports = fetchQuery;