react-relay/lib/relay-experimental/preloadQuery.js

/**
 * 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
 */
'use strict';

var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

var ReplaySubject = require('relay-runtime/lib/util/RelayReplaySubject');

var getRequestIdentifier = require('relay-runtime/lib/util/getRequestIdentifier');

var invariant = require("fbjs/lib/invariant");

var _require = require('relay-runtime'),
    createOperationDescriptor = _require.createOperationDescriptor,
    Environment = _require.Environment,
    getRequest = _require.getRequest,
    Observable = _require.Observable;

// Expire results by this delay after they resolve.
var DEFAULT_PREFETCH_TIMEOUT = 30 * 1000; // 30 seconds

var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
var STORE_OR_NETWORK_DEFAULT = 'store-or-network';
var pendingQueriesByEnvironment = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();

function preloadQuery(environment, preloadableRequest, variables, options, environmentProviderOptions) {
  !(environment instanceof Environment) ? process.env.NODE_ENV !== "production" ? invariant(false, 'preloadQuery(): Expected a RelayModernEnvironment') : invariant(false) : void 0;

  var _pendingQueries = pendingQueriesByEnvironment.get(environment);

  if (_pendingQueries == null) {
    _pendingQueries = new Map();
    pendingQueriesByEnvironment.set(environment, _pendingQueries);
  }

  var pendingQueries = _pendingQueries; // store in a const for flow

  var queryEntry = preloadQueryDeduped(environment, pendingQueries, preloadableRequest, variables, options);
  var source = queryEntry.kind === 'network' ? Observable.create(function (sink) {
    var subscription = queryEntry.subject.subscribe(sink);
    return function () {
      subscription.unsubscribe();
      cleanup(pendingQueries, queryEntry);
    };
  }) : null;
  return {
    environment: environment,
    environmentProviderOptions: environmentProviderOptions,
    fetchKey: queryEntry.fetchKey,
    fetchPolicy: queryEntry.fetchPolicy,
    name: queryEntry.name,
    source: source,
    variables: variables
  };
}

function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, variables, options) {
  var _ref;

  var params;
  var query;

  if (typeof preloadableRequest.getModuleIfRequired === 'function') {
    var preloadableConcreteRequest = preloadableRequest;
    params = preloadableConcreteRequest.params;
    query = preloadableConcreteRequest.getModuleIfRequired();
  } else {
    query = getRequest(preloadableRequest);
    params = query.params;
  }

  var network = environment.getNetwork();
  var fetchPolicy = (_ref = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _ref !== void 0 ? _ref : STORE_OR_NETWORK_DEFAULT;
  var fetchKey = options === null || options === void 0 ? void 0 : options.fetchKey;
  var cacheKey = "".concat(getRequestIdentifier(params, variables)).concat(fetchKey != null ? "-".concat(fetchKey) : '');
  var prevQueryEntry = pendingQueries.get(cacheKey);
  var shouldFulfillFromCache = fetchPolicy === STORE_OR_NETWORK_DEFAULT && query != null && ((prevQueryEntry === null || prevQueryEntry === void 0 ? void 0 : prevQueryEntry.kind) === 'cache' || environment.check(createOperationDescriptor(query, variables).root));
  var nextQueryEntry;

  if (shouldFulfillFromCache) {
    nextQueryEntry = prevQueryEntry && prevQueryEntry.kind === 'cache' ? prevQueryEntry : {
      cacheKey: cacheKey,
      fetchKey: fetchKey,
      fetchPolicy: fetchPolicy,
      kind: 'cache',
      name: params.name
    };

    if (ExecutionEnvironment.canUseDOM && prevQueryEntry == null) {
      setTimeout(function () {
        // Clear the cache entry after the default timeout
        // null-check for Flow
        if (nextQueryEntry != null) {
          cleanup(pendingQueries, nextQueryEntry);
        }
      }, DEFAULT_PREFETCH_TIMEOUT);
    }
  } else if (prevQueryEntry == null || prevQueryEntry.kind !== 'network') {
    // Should fetch but we're not already fetching: fetch!
    var _environment$__create = environment.__createLogObserver(params, variables),
        logObserver = _environment$__create[0],
        logRequestInfo = _environment$__create[1];

    var source = network.execute(params, variables, {}, null, logRequestInfo);
    var subject = new ReplaySubject();
    nextQueryEntry = {
      cacheKey: cacheKey,
      fetchKey: fetchKey,
      fetchPolicy: fetchPolicy,
      kind: 'network',
      name: params.name,
      subject: subject,
      subscription: source["finally"](function () {
        if (!ExecutionEnvironment.canUseDOM) {
          return;
        }

        setTimeout(function () {
          // Clear the cache entry after the default timeout
          // null-check for Flow
          if (nextQueryEntry != null) {
            cleanup(pendingQueries, nextQueryEntry);
          }
        }, DEFAULT_PREFETCH_TIMEOUT);
      })["do"](logObserver).subscribe({
        complete: function complete() {
          subject.complete();
        },
        error: function error(_error) {
          subject.error(_error);
        },
        next: function next(response) {
          subject.next(response);
        }
      })
    };
  } else {
    nextQueryEntry = prevQueryEntry;
  }

  pendingQueries.set(cacheKey, nextQueryEntry);
  return nextQueryEntry;
}

function cleanup(pendingQueries, entry) {
  // Reload the entry by its cache key and only invalidate if its the identical
  // entry instance. This ensures that if the same query/variables are fetched
  // successively that a timeout/expiration from an earlier fetch doesn't clear
  // a subsequent fetch.
  var currentEntry = pendingQueries.get(entry.cacheKey);

  if (currentEntry != null && currentEntry === entry) {
    if (currentEntry.kind === 'network') {
      currentEntry.subscription.unsubscribe();
    }

    pendingQueries["delete"](currentEntry.cacheKey);
  }
}

module.exports = preloadQuery;