"use strict";;
const {
    __DEV__
} = require("@apollo/client/utilities/environment");

Object.defineProperty(exports, "__esModule", { value: true });
exports.ApolloClient = void 0;
const graphql_1 = require("graphql");
const rxjs_1 = require("rxjs");
const incremental_1 = require("@apollo/client/incremental");
const link_1 = require("@apollo/client/link");
const utilities_1 = require("@apollo/client/utilities");
const environment_1 = require("@apollo/client/utilities/environment");
const internal_1 = require("@apollo/client/utilities/internal");
const invariant_1 = require("@apollo/client/utilities/invariant");
const version_js_1 = require("../version.cjs");
const QueryManager_js_1 = require("./QueryManager.cjs");
let hasSuggestedDevtools = false;
/**
 * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries
 * and mutations) to a GraphQL spec-compliant server over an `ApolloLink` instance,
 * receive results from the server and cache the results in a store. It also delivers updates
 * to GraphQL queries through `Observable` instances.
 */
class ApolloClient {
    link;
    cache;
    /**
     * @deprecated `disableNetworkFetches` has been renamed to `prioritizeCacheValues`.
     */
    disableNetworkFetches;
    set prioritizeCacheValues(value) {
        this.queryManager.prioritizeCacheValues = value;
    }
    /**
     * Whether to prioritize cache values over network results when `query` or `watchQuery` is called.
     * This will essentially turn a `"network-only"` or `"cache-and-network"` fetchPolicy into a `"cache-first"` fetchPolicy,
     * but without influencing the `fetchPolicy` of the created `ObservableQuery` long-term.
     *
     * This can e.g. be used to prioritize the cache during the first render after SSR.
     */
    get prioritizeCacheValues() {
        return this.queryManager.prioritizeCacheValues;
    }
    version;
    queryDeduplication;
    defaultOptions;
    devtoolsConfig;
    queryManager;
    devToolsHookCb;
    resetStoreCallbacks = [];
    clearStoreCallbacks = [];
    /**
     * Constructs an instance of `ApolloClient`.
     *
     * @example
     *
     * ```js
     * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
     *
     * const cache = new InMemoryCache();
     * const link = new HttpLink({ uri: "http://localhost:4000/" });
     *
     * const client = new ApolloClient({
     *   // Provide required constructor fields
     *   cache: cache,
     *   link: link,
     *
     *   // Provide some optional constructor fields
     *   clientAwareness: {
     *     name: "react-web-client",
     *     version: "1.3",
     *   },
     *   queryDeduplication: false,
     * });
     * ```
     */
    constructor(options) {
        if (environment_1.__DEV__) {
            (0, invariant_1.invariant)(options.cache, 68);
            (0, invariant_1.invariant)(options.link, 69);
        }
        const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new incremental_1.NotImplementedHandler(), experiments = [], } = options;
        this.link = link;
        this.cache = cache;
        this.queryDeduplication = queryDeduplication;
        this.defaultOptions = defaultOptions || {};
        this.devtoolsConfig = {
            ...devtools,
            enabled: devtools?.enabled ?? environment_1.__DEV__,
        };
        this.watchQuery = this.watchQuery.bind(this);
        this.query = this.query.bind(this);
        this.mutate = this.mutate.bind(this);
        this.watchFragment = this.watchFragment.bind(this);
        this.resetStore = this.resetStore.bind(this);
        this.reFetchObservableQueries = this.refetchObservableQueries =
            this.refetchObservableQueries.bind(this);
        this.version = version_js_1.version;
        this.queryManager = new QueryManager_js_1.QueryManager({
            client: this,
            defaultOptions: this.defaultOptions,
            defaultContext,
            documentTransform,
            queryDeduplication,
            ssrMode,
            dataMasking: !!dataMasking,
            clientOptions: options,
            incrementalHandler,
            assumeImmutableResults,
            onBroadcast: this.devtoolsConfig.enabled ?
                () => {
                    if (this.devToolsHookCb) {
                        this.devToolsHookCb();
                    }
                }
                : void 0,
            localState,
        });
        this.prioritizeCacheValues = ssrMode || ssrForceFetchDelay > 0;
        if (ssrForceFetchDelay) {
            setTimeout(() => {
                this.prioritizeCacheValues = false;
            }, ssrForceFetchDelay);
        }
        if (this.devtoolsConfig.enabled)
            this.connectToDevTools();
        experiments.forEach((experiment) => experiment.call(this, options));
    }
    connectToDevTools() {
        if (typeof window === "undefined") {
            return;
        }
        const windowWithDevTools = window;
        const devtoolsSymbol = Symbol.for("apollo.devtools");
        (windowWithDevTools[devtoolsSymbol] =
            windowWithDevTools[devtoolsSymbol] || []).push(this);
        windowWithDevTools.__APOLLO_CLIENT__ = this;
        /**
         * Suggest installing the devtools for developers who don't have them
         */
        if (!hasSuggestedDevtools && environment_1.__DEV__) {
            hasSuggestedDevtools = true;
            if (window.document &&
                window.top === window.self &&
                /^(https?|file):$/.test(window.location.protocol)) {
                setTimeout(() => {
                    if (!window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {
                        const nav = window.navigator;
                        const ua = nav && nav.userAgent;
                        let url;
                        if (typeof ua === "string") {
                            if (ua.indexOf("Chrome/") > -1) {
                                url =
                                    "https://chrome.google.com/webstore/detail/" +
                                        "apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm";
                            }
                            else if (ua.indexOf("Firefox/") > -1) {
                                url =
                                    "https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/";
                            }
                        }
                        if (url) {
                            __DEV__ && invariant_1.invariant.log("Download the Apollo DevTools for a better development " +
                                "experience: %s", url);
                        }
                    }
                }, 10000);
            }
        }
    }
    /**
     * The `DocumentTransform` used to modify GraphQL documents before a request
     * is made. If a custom `DocumentTransform` is not provided, this will be the
     * default document transform.
     */
    get documentTransform() {
        return this.queryManager.documentTransform;
    }
    /**
     * The configured `LocalState` instance used to enable the use of `@client`
     * fields.
     */
    get localState() {
        return this.queryManager.localState;
    }
    set localState(localState) {
        this.queryManager.localState = localState;
    }
    /**
     * Call this method to terminate any active client processes, making it safe
     * to dispose of this `ApolloClient` instance.
     *
     * This method performs aggressive cleanup to prevent memory leaks:
     *
     * - Unsubscribes all active `ObservableQuery` instances by emitting a `completed` event
     * - Rejects all currently running queries with "QueryManager stopped while query was in flight"
     * - Removes all queryRefs from the suspense cache
     */
    stop() {
        this.queryManager.stop();
    }
    /**
     * This watches the cache store of the query according to the options specified and
     * returns an `ObservableQuery`. We can subscribe to this `ObservableQuery` and
     * receive updated results through an observer when the cache store changes.
     *
     * Note that this method is not an implementation of GraphQL subscriptions. Rather,
     * it uses Apollo's store in order to reactively deliver updates to your query results.
     *
     * For example, suppose you call watchQuery on a GraphQL query that fetches a person's
     * first and last name and this person has a particular object identifier, provided by
     * `cache.identify`. Later, a different query fetches that same person's
     * first and last name and the first name has now changed. Then, any observers associated
     * with the results of the first query will be updated with a new result object.
     *
     * Note that if the cache does not change, the subscriber will _not_ be notified.
     *
     * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for
     * a description of store reactivity.
     */
    watchQuery(options) {
        if (this.defaultOptions.watchQuery) {
            options = (0, internal_1.mergeOptions)(this.defaultOptions.watchQuery, options);
        }
        return this.queryManager.watchQuery(options);
    }
    /**
     * This resolves a single query according to the options specified and
     * returns a `Promise` which is either resolved with the resulting data
     * or rejected with an error.
     *
     * @param options - An object of type `QueryOptions` that allows us to
     * describe how this query should be treated e.g. whether it should hit the
     * server at all or just resolve from the cache, etc.
     */
    query(options) {
        if (this.defaultOptions.query) {
            options = (0, internal_1.mergeOptions)(this.defaultOptions.query, options);
        }
        if (environment_1.__DEV__) {
            (0, invariant_1.invariant)(options.fetchPolicy !== "cache-and-network", 70);
            (0, invariant_1.invariant)(options.fetchPolicy !== "standby", 71);
            (0, invariant_1.invariant)(options.query, 72);
            (0, invariant_1.invariant)(options.query.kind === "Document", 73);
            (0, invariant_1.invariant)(!options.returnPartialData, 74);
            (0, invariant_1.invariant)(!options.pollInterval, 75);
            (0, invariant_1.invariant)(!options.notifyOnNetworkStatusChange, 76);
        }
        return this.queryManager.query(options);
    }
    /**
     * This resolves a single mutation according to the options specified and returns a
     * Promise which is either resolved with the resulting data or rejected with an
     * error. In some cases both `data` and `errors` might be undefined, for example
     * when `errorPolicy` is set to `'ignore'`.
     *
     * It takes options as an object with the following keys and values:
     */
    mutate(options) {
        const optionsWithDefaults = (0, internal_1.mergeOptions)((0, internal_1.compact)({
            fetchPolicy: "network-only",
            errorPolicy: "none",
        }, this.defaultOptions.mutate), options);
        if (environment_1.__DEV__) {
            (0, invariant_1.invariant)(optionsWithDefaults.mutation, 77);
            (0, invariant_1.invariant)(optionsWithDefaults.fetchPolicy === "network-only" ||
                optionsWithDefaults.fetchPolicy === "no-cache", 78);
        }
        (0, internal_1.checkDocument)(optionsWithDefaults.mutation, graphql_1.OperationTypeNode.MUTATION);
        return this.queryManager.mutate(optionsWithDefaults);
    }
    /**
     * This subscribes to a graphql subscription according to the options specified and returns an
     * `Observable` which either emits received data or an error.
     */
    subscribe(options) {
        const cause = {};
        const observable = this.queryManager.startGraphQLSubscription(options);
        const mapped = observable.pipe((0, rxjs_1.map)((result) => ({
            ...result,
            data: this.queryManager.maskOperation({
                document: options.query,
                data: result.data,
                fetchPolicy: options.fetchPolicy,
                cause,
            }),
        })));
        return Object.assign(mapped, { restart: observable.restart });
    }
    readQuery(options, optimistic = false) {
        return this.cache.readQuery({ ...options, query: this.transform(options.query) }, optimistic);
    }
    watchFragment(options) {
        const dataMasking = this.queryManager.dataMasking;
        const observable = this.cache.watchFragment({
            ...options,
            fragment: this.transform(options.fragment, dataMasking),
        });
        if (environment_1.__DEV__) {
            return (0, internal_1.mapObservableFragmentMemoized)(observable, Symbol.for("apollo.transform.dev.mask"), (result) => ({
                ...result,
                // The transform will remove fragment spreads from the fragment
                // document when dataMasking is enabled. The `mask` function
                // remains to apply warnings to fragments marked as
                // `@unmask(mode: "migrate")`. Since these warnings are only applied
                // in dev, we can skip the masking algorithm entirely for production.
                data: this.queryManager.maskFragment({
                    ...options,
                    data: result.data,
                }),
            }));
        }
        return observable;
    }
    readFragment(options, optimistic = false) {
        return this.cache.readFragment({ ...options, fragment: this.transform(options.fragment) }, optimistic);
    }
    /**
     * Writes some data in the shape of the provided GraphQL query directly to
     * the store. This method will start at the root query. To start at a
     * specific id returned by `cache.identify` then use `writeFragment`.
     */
    writeQuery(options) {
        const ref = this.cache.writeQuery(options);
        if (options.broadcast !== false) {
            this.queryManager.broadcastQueries();
        }
        return ref;
    }
    /**
     * Writes some data in the shape of the provided GraphQL fragment directly to
     * the store. This method will write to a GraphQL fragment from any arbitrary
     * id that is currently cached, unlike `writeQuery` which will only write
     * from the root query.
     *
     * You must pass in a GraphQL document with a single fragment or a document
     * with multiple fragments that represent what you are writing. If you pass
     * in a document with multiple fragments then you must also specify a
     * `fragmentName`.
     */
    writeFragment(options) {
        const ref = this.cache.writeFragment(options);
        if (options.broadcast !== false) {
            this.queryManager.broadcastQueries();
        }
        return ref;
    }
    __actionHookForDevTools(cb) {
        this.devToolsHookCb = cb;
    }
    __requestRaw(request) {
        return (0, link_1.execute)(this.link, request, { client: this });
    }
    /**
     * Resets your entire store by clearing out your cache and then re-executing
     * all of your active queries. This makes it so that you may guarantee that
     * there is no data left in your store from a time before you called this
     * method.
     *
     * `resetStore()` is useful when your user just logged out. You’ve removed the
     * user session, and you now want to make sure that any references to data you
     * might have fetched while the user session was active is gone.
     *
     * It is important to remember that `resetStore()` _will_ refetch any active
     * queries. This means that any components that might be mounted will execute
     * their queries again using your network interface. If you do not want to
     * re-execute any queries then you should make sure to stop watching any
     * active queries.
     */
    resetStore() {
        return Promise.resolve()
            .then(() => this.queryManager.clearStore({
            discardWatches: false,
        }))
            .then(() => Promise.all(this.resetStoreCallbacks.map((fn) => fn())))
            .then(() => this.refetchObservableQueries());
    }
    /**
     * Remove all data from the store. Unlike `resetStore`, `clearStore` will
     * not refetch any active queries.
     */
    clearStore() {
        return Promise.resolve()
            .then(() => this.queryManager.clearStore({
            discardWatches: true,
        }))
            .then(() => Promise.all(this.clearStoreCallbacks.map((fn) => fn())));
    }
    /**
     * Allows callbacks to be registered that are executed when the store is
     * reset. `onResetStore` returns an unsubscribe function that can be used
     * to remove registered callbacks.
     */
    onResetStore(cb) {
        this.resetStoreCallbacks.push(cb);
        return () => {
            this.resetStoreCallbacks = this.resetStoreCallbacks.filter((c) => c !== cb);
        };
    }
    /**
     * Allows callbacks to be registered that are executed when the store is
     * cleared. `onClearStore` returns an unsubscribe function that can be used
     * to remove registered callbacks.
     */
    onClearStore(cb) {
        this.clearStoreCallbacks.push(cb);
        return () => {
            this.clearStoreCallbacks = this.clearStoreCallbacks.filter((c) => c !== cb);
        };
    }
    /**
     * Refetches all of your active queries.
     *
     * `reFetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage
     *
     * It is important to remember that `reFetchObservableQueries()` _will_ refetch any active
     * queries. This means that any components that might be mounted will execute
     * their queries again using your network interface. If you do not want to
     * re-execute any queries then you should make sure to stop watching any
     * active queries.
     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
     *
     * Note: `cache-only` queries are not refetched by this function.
     *
     * @deprecated Please use `refetchObservableQueries` instead.
     */
    reFetchObservableQueries;
    /**
     * Refetches all of your active queries.
     *
     * `refetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage
     *
     * It is important to remember that `refetchObservableQueries()` _will_ refetch any active
     * queries. This means that any components that might be mounted will execute
     * their queries again using your network interface. If you do not want to
     * re-execute any queries then you should make sure to stop watching any
     * active queries.
     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
     *
     * Note: `cache-only` queries are not refetched by this function.
     */
    refetchObservableQueries(includeStandby) {
        return this.queryManager.refetchObservableQueries(includeStandby);
    }
    /**
     * Refetches specified active queries. Similar to "refetchObservableQueries()" but with a specific list of queries.
     *
     * `refetchQueries()` is useful for use cases to imperatively refresh a selection of queries.
     *
     * It is important to remember that `refetchQueries()` _will_ refetch specified active
     * queries. This means that any components that might be mounted will execute
     * their queries again using your network interface. If you do not want to
     * re-execute any queries then you should make sure to stop watching any
     * active queries.
     */
    refetchQueries(options) {
        const map = this.queryManager.refetchQueries(options);
        const queries = [];
        const results = [];
        map.forEach((result, obsQuery) => {
            queries.push(obsQuery);
            results.push(result);
        });
        const result = Promise.all(results);
        // In case you need the raw results immediately, without awaiting
        // Promise.all(results):
        result.queries = queries;
        result.results = results;
        // If you decide to ignore the result Promise because you're using
        // result.queries and result.results instead, you shouldn't have to worry
        // about preventing uncaught rejections for the Promise.all result.
        result.catch((error) => {
            __DEV__ && invariant_1.invariant.debug(79, error);
        });
        return result;
    }
    /**
     * Get all currently active `ObservableQuery` objects, in a `Set`.
     *
     * An "active" query is one that has observers and a `fetchPolicy` other than
     * "standby" or "cache-only".
     *
     * You can include all `ObservableQuery` objects (including the inactive ones)
     * by passing "all" instead of "active", or you can include just a subset of
     * active queries by passing an array of query names or DocumentNode objects.
     *
     * Note: This method only returns queries that have active subscribers. Queries
     * without subscribers are not tracked by the client.
     */
    getObservableQueries(include = "active") {
        return this.queryManager.getObservableQueries(include);
    }
    /**
     * Exposes the cache's complete state, in a serializable format for later restoration.
     *
     * @remarks
     *
     * This can be useful for debugging in order to inspect the full state of the
     * cache.
     *
     * @param optimistic - Determines whether the result contains data from the
     * optimistic layer
     */
    extract(optimistic) {
        return this.cache.extract(optimistic);
    }
    /**
     * Replaces existing state in the cache (if any) with the values expressed by
     * `serializedState`.
     *
     * Called when hydrating a cache (server side rendering, or offline storage),
     * and also (potentially) during hot reloads.
     */
    restore(serializedState) {
        return this.cache.restore(serializedState);
    }
    /**
     * Define a new ApolloLink (or link chain) that Apollo Client will use.
     */
    setLink(newLink) {
        this.link = newLink;
    }
    get defaultContext() {
        return this.queryManager.defaultContext;
    }
    maskedFragmentTransform = new utilities_1.DocumentTransform(internal_1.removeMaskedFragmentSpreads);
    transform(document, dataMasking = false) {
        const transformed = this.queryManager.transform(document);
        return dataMasking ?
            this.maskedFragmentTransform.transformDocument(transformed)
            : transformed;
    }
}
exports.ApolloClient = ApolloClient;
if (environment_1.__DEV__) {
    ApolloClient.prototype.getMemoryInternals = internal_1.getApolloClientMemoryInternals;
}
//# sourceMappingURL=ApolloClient.cjs.map
