graphql-persisted 0.0.5 → 0.0.6

package/cjs/GraphQLQueryCache.d.ts

@@ -1,10 +1,33 @@
-import type { GraphQLCacheShape, GraphQLMutationResult, GraphQLOperationResult, GraphQLQueryCacheConfig, GraphQLQueryResult, InvalidateQueryArgs, MaybePromise, ExecutionOptions, ReadQueryArgs, SerializedVariables, SubscribeToQueryArgs, PreloadQueryOptions } from './types';
+import { NormalizeMetaShape } from 'graphql-normalize';
+import type { GraphQLCacheShape, GraphQLMutationResult, GraphQLOperationResult, GraphQLQueryCacheConfig, GraphQLQueryResult, GraphQLRequestBody, InvalidateQueryArgs, MaybePromise, ExecutionOptions, PersistedQueryOptions, ReadQueryArgs, SerializedVariables, SubscribeToQueryArgs, PreloadQueryOptions } from './types';
 /**
  * Manages the cached normalized state, and the execution of
  * data accessed by different components
  */
 export declare class GraphQLQueryCache {
-    #private;
+    /**
+     * If an alterative fetch is provided, we will use that for operations
+     * Otherwise we'll use the native 'fetch'
+     */
+    private _fetcher?;
+    /**
+     * GraphQL API endpoint
+     * @default /graphql
+     */
+    private _endpoint;
+    private _persistedOperations;
+    private _persistedDocuments?;
+    private _configMeta?;
+    private _subscribedQueries;
+    private _inFlight;
+    private _cacheStore;
+    private _runtimeCache;
+    private _queryInvalidation;
+    private _mutationInvalidation;
+    /**
+     * A list of all "effects" that have run, used to keep track of
+     */
+    private _effectsIssued;
     constructor(config: GraphQLQueryCacheConfig);
     /**
      * Invalidates a query by name or predicate fn
@@ -53,10 +76,31 @@ export declare class GraphQLQueryCache {
      */
     executeQuery<Q extends keyof GraphQLQuery.QueryRegistry>(queryName: Q, variables: SerializedVariables | GraphQLQuery.OperationVariables[Q]): Promise<GraphQLQueryResult<Q>>;
     executeSubscription(): Promise<void>;
+    _getKey(operationName: string, variables: SerializedVariables | object): string;
     /**
      * "Subscribes" to a query, meaning that when there are updates to fields in the
      * field cache, we'll re-materialize the known value of the query. We'll also
      * process based on configuration options, such as TTL, invalidateOnMutation
      */
     subscribeToQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: SubscribeToQueryArgs<Q>): () => void;
+    _executeOperation<QueryName extends keyof GraphQLQuery.QueryRegistry>(operationType: 'query', operationName: QueryName, variables: SerializedVariables | GraphQLQuery.OperationVariables[QueryName], options?: PersistedQueryOptions): Promise<GraphQLQueryResult<QueryName>>;
+    _executeOperation<MutationName extends keyof GraphQLQuery.MutationRegistry>(operationType: 'mutation', operationName: MutationName, variables: SerializedVariables | object, options?: ExecutionOptions): Promise<GraphQLMutationResult<MutationName>>;
+    _getMeta(opName: string): NormalizeMetaShape;
+    /**
+     * Handles "fetch", ensuring we catch network errors and handle non-200
+     * responses properly so we're able to forward these on in a normalized fashion
+     */
+    _fetch(body: GraphQLRequestBody): Promise<GraphQLOperationResult<any>>;
+    _makeFetch(body: GraphQLRequestBody): Promise<Response>;
+    /**
+     * Determine whether we should refetch the query based on the
+     * current value of the query, and the options passed to the query
+     */
+    _shouldRefetchQuery(): void;
+    /**
+     * "Garbage collection" for existing operations. If they have
+     * a TTL or are invalidated by other operations, and aren't mounted,
+     * then we can go ahead and sweep out any data we might have for them
+     */
+    _gcOperations(): void;
 }

package/cjs/GraphQLQueryCache.js

@@ -1,5 +1,4 @@
 "use strict";
-var _GraphQLQueryCache_instances, _GraphQLQueryCache_fetcher, _GraphQLQueryCache_endpoint, _GraphQLQueryCache_persistedOperations, _GraphQLQueryCache_persistedDocuments, _GraphQLQueryCache_configMeta, _GraphQLQueryCache_subscribedQueries, _GraphQLQueryCache_inFlight, _GraphQLQueryCache_cacheStore, _GraphQLQueryCache_runtimeCache, _GraphQLQueryCache_queryInvalidation, _GraphQLQueryCache_mutationInvalidation, _GraphQLQueryCache_effectsIssued, _GraphQLQueryCache_getKey, _GraphQLQueryCache_executeOperation, _GraphQLQueryCache_getMeta, _GraphQLQueryCache_fetch, _GraphQLQueryCache_makeFetch, _GraphQLQueryCache_shouldRefetchQuery, _GraphQLQueryCache_gcOperations;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLQueryCache = void 0;
 const tslib_1 = require("tslib");
@@ -14,67 +13,38 @@ const helpers_1 = require("./helpers");
  */
 class GraphQLQueryCache {
     constructor(config) {
-        _GraphQLQueryCache_instances.add(this);
-        /**
-         * If an alterative fetch is provided, we will use that for operations
-         * Otherwise we'll use the native 'fetch'
-         */
-        _GraphQLQueryCache_fetcher.set(this, void 0);
-        /**
-         * GraphQL API endpoint
-         * @default /graphql
-         */
-        _GraphQLQueryCache_endpoint.set(this, void 0);
-        // A mapping of OperationName -> Operation Hash. The operation hash is sent to the
-        // server when we issue a query
-        _GraphQLQueryCache_persistedOperations.set(this, void 0);
-        // Mapping of persisted documents
-        _GraphQLQueryCache_persistedDocuments.set(this, void 0);
-        // A mapping of metadata between the config string and normalized metadata shape
-        _GraphQLQueryCache_configMeta.set(this, void 0);
         // All queries we are "subscribed to", meaning that we React to any changes
         // when there are updates to the cache.
-        _GraphQLQueryCache_subscribedQueries.set(this, {}
+        this._subscribedQueries = {};
         // All "in-flight" fetches, to deduplicate fetches that are already in-flight
         // for an operation
-        );
-        // All "in-flight" fetches, to deduplicate fetches that are already in-flight
-        // for an operation
-        _GraphQLQueryCache_inFlight.set(this, {}
-        // Immutable object containing the normalized cache of all data
-        // as well as all operations we're tracking within the application
-        );
-        // Immutable object containing the normalized cache of all data
-        // as well as all operations we're tracking within the application
-        _GraphQLQueryCache_cacheStore.set(this, void 0);
+        this._inFlight = {};
         // Keeps track of all the operations that have been issued in the application,
         // as well as the metadata indicating the TTL / polling / invalidation / refetch
         // logic necessary to keep things up to date
-        _GraphQLQueryCache_runtimeCache.set(this, {});
-        _GraphQLQueryCache_queryInvalidation.set(this, void 0);
-        _GraphQLQueryCache_mutationInvalidation.set(this, void 0);
+        this._runtimeCache = {};
         /**
          * A list of all "effects" that have run, used to keep track of
          */
-        _GraphQLQueryCache_effectsIssued.set(this, []); // TODO: Include subscriptions
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_fetcher, config.fetcher, "f");
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_endpoint, config.endpoint || `/graphql`, "f");
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_persistedOperations, config.persistedOperations, "f");
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_persistedDocuments, config.persistedDocuments, "f");
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_configMeta, unwrapMeta(config.meta), "f");
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_queryInvalidation, config.queryInvalidation ?? {}, "f");
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_mutationInvalidation, config.mutationInvalidation ?? {}, "f");
-        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, (0, immer_1.produce)(config.hydratedCache ?? {
+        this._effectsIssued = []; // TODO: Include subscriptions
+        this._fetcher = config.fetcher;
+        this._endpoint = config.endpoint || `/graphql`;
+        this._persistedOperations = config.persistedOperations;
+        this._persistedDocuments = config.persistedDocuments;
+        this._configMeta = unwrapMeta(config.meta);
+        this._queryInvalidation = config.queryInvalidation ?? {};
+        this._mutationInvalidation = config.mutationInvalidation ?? {};
+        this._cacheStore = (0, immer_1.produce)(config.hydratedCache ?? {
             meta: {},
             fields: {},
             operations: {},
-        }, noop), "f");
+        }, noop);
     }
     /**
      * Invalidates a query by name or predicate fn
      */
     invalidateQuery(toInvalidate) {
-        (0, immer_1.produce)(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+        (0, immer_1.produce)(this._runtimeCache, () => {
             //
         });
     }
@@ -82,7 +52,7 @@ class GraphQLQueryCache {
      * Invalidates a query by name or predicate fn
      */
     refetchQuery(toRefetch) {
-        (0, immer_1.produce)(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+        (0, immer_1.produce)(this._runtimeCache, () => {
             //
         });
     }
@@ -91,7 +61,7 @@ class GraphQLQueryCache {
      * to rehydrate the Client
      */
     toJSON() {
-        const { fields, operations, meta } = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
+        const { fields, operations, meta } = this._cacheStore;
         return {
             fields,
             operations: operations,
@@ -105,7 +75,7 @@ class GraphQLQueryCache {
     //   queryName: Q,
     //   variable: SerializedVariables | GraphQLQuery.OperationVariables[Q]
     // ) {
-    //   // Object.values(this.#cacheStore.operations).find((o) => {
+    //   // Object.values(this._cacheStore.operations).find((o) => {
     //   //   return o.operationType === 'query' && o
     //   // })
     // }
@@ -129,19 +99,19 @@ class GraphQLQueryCache {
      */
     readQuery(args) {
         const { queryName, variables, options } = args;
-        const key = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, queryName, variables);
-        const op = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key];
+        const key = this._getKey(queryName, variables);
+        const op = this._cacheStore.operations[key];
         if (op) {
             return op;
         }
         // If we don't have metadata, we can't know how to read the query
         // from the cache
-        const meta = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getMeta).call(this, queryName);
+        const meta = this._getMeta(queryName);
         const { result } = (0, graphql_normalize_1.graphqlNormalize)({
             action: 'read',
             variableValues: typeof variables === 'string' ? JSON.parse(variables) : variables,
             meta: meta,
-            cache: tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").fields,
+            cache: this._cacheStore.fields,
             isEqual: lodash_isequal_1.default,
         });
         return {
@@ -176,9 +146,9 @@ class GraphQLQueryCache {
     preloadQuery(queryName, options) {
         const { blockIfStale = true } = options;
         const variables = (0, helpers_1.variableString)(options.variables ?? {});
-        const sha256Hash = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[queryName];
+        const sha256Hash = this._persistedOperations[queryName];
         const key = `${sha256Hash}:${variables}`;
-        const operation = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key];
+        const operation = this._cacheStore.operations[key];
         // TODO: Give an option to eager return if we already have the operation but it's stale
         if (!operation || operation.stale) {
             const inFlight = this.fetchQuery({ queryName, variables: variables, options: {} });
@@ -187,23 +157,27 @@ class GraphQLQueryCache {
         return operation;
     }
     fetchQuery(args) {
-        return tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_executeOperation).call(this, 'query', args.queryName, args.variables, args.options);
+        return this._executeOperation('query', args.queryName, args.variables, args.options);
     }
     /**
      * Executes a mutation, returning the result of that mutation
      */
     async executeMutation(mutationName, variables, options = {}) {
-        return tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_executeOperation).call(this, 'mutation', mutationName, variables, options);
+        return this._executeOperation('mutation', mutationName, variables, options);
     }
     /**
      * Executes a query, returning the result of that query
      */
     async executeQuery(queryName, variables) {
-        return tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_executeOperation).call(this, 'query', queryName, variables);
+        return this._executeOperation('query', queryName, variables);
     }
     async executeSubscription() {
         throw new Error('Not yet supported');
     }
+    _getKey(operationName, variables) {
+        const sha256Hash = this._persistedOperations[operationName];
+        return `${sha256Hash}:${(0, helpers_1.variableString)(variables)}`;
+    }
     /**
      * "Subscribes" to a query, meaning that when there are updates to fields in the
      * field cache, we'll re-materialize the known value of the query. We'll also
@@ -212,208 +186,217 @@ class GraphQLQueryCache {
     subscribeToQuery(args) {
         var _a;
         const { queryName, queryResult, variables, onUpdate, options } = args;
-        const key = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, queryName, variables);
-        const queries = ((_a = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_subscribedQueries, "f"))[key] ?? (_a[key] = []));
+        const key = this._getKey(queryName, variables);
+        const queries = ((_a = this._subscribedQueries)[key] ?? (_a[key] = []));
         queries.push(args);
         // Now that the component is subscribed, we can begin fetching,
         // refetching, and otherwise managing the query
         if (!queryResult) {
-            //
+            this.readOrFetchQuery(args);
         }
         else if (options.ttl) {
             //
         }
-        // this.fetchQuery(args)
         return () => {
             queries.splice(queries.indexOf(args), 1);
         };
     }
-}
-exports.GraphQLQueryCache = GraphQLQueryCache;
-_GraphQLQueryCache_fetcher = new WeakMap(), _GraphQLQueryCache_endpoint = new WeakMap(), _GraphQLQueryCache_persistedOperations = new WeakMap(), _GraphQLQueryCache_persistedDocuments = new WeakMap(), _GraphQLQueryCache_configMeta = new WeakMap(), _GraphQLQueryCache_subscribedQueries = new WeakMap(), _GraphQLQueryCache_inFlight = new WeakMap(), _GraphQLQueryCache_cacheStore = new WeakMap(), _GraphQLQueryCache_runtimeCache = new WeakMap(), _GraphQLQueryCache_queryInvalidation = new WeakMap(), _GraphQLQueryCache_mutationInvalidation = new WeakMap(), _GraphQLQueryCache_effectsIssued = new WeakMap(), _GraphQLQueryCache_instances = new WeakSet(), _GraphQLQueryCache_getKey = function _GraphQLQueryCache_getKey(operationName, variables) {
-    const sha256Hash = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[operationName];
-    return `${sha256Hash}:${(0, helpers_1.variableString)(variables)}`;
-}, _GraphQLQueryCache_executeOperation = async function _GraphQLQueryCache_executeOperation(operationType, operationName, variables) {
-    const sha256Hash = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[operationName];
-    const key = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, operationName, variables);
-    const operationVariables = (0, helpers_1.variableObject)(variables);
-    (0, errors_1.assertOperationHash)(sha256Hash, operationType, operationName);
-    const inFlight = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key];
-    if (operationType === 'query' && inFlight) {
-        return inFlight;
-    }
-    const operationInFlight = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_fetch).call(this, {
-        query: '',
-        operationName,
-        variables: operationVariables,
-        extensions: {
-            persistedQuery: { version: 1, sha256Hash },
-        },
-    });
-    tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key] = operationInFlight;
-    const operationResult = await operationInFlight.finally(() => {
-        delete tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key];
-    });
-    if (operationResult.fetchError) {
-        return operationResult;
-    }
-    const meta = operationResult.extensions?.['graphqlNormalizeMeta'] ??
-        tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getMeta).call(this, operationName);
-    // Ensure we have metadata to be able to normalize the operation in our cache
-    if (!meta) {
-        throw new errors_1.MissingMetaError(operationName);
-    }
-    const lastCache = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
-    tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, (0, immer_1.produce)(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f"), (c) => {
-        const currentResult = c.operations[key];
-        const { added, modified, result } = (0, graphql_normalize_1.graphqlNormalize)({
-            action: 'write',
-            operationResult,
-            meta,
-            cache: c.fields,
-            variableValues: operationVariables,
-            currentResult,
-            isEqual: lodash_isequal_1.default,
+    async _executeOperation(operationType, operationName, variables) {
+        const sha256Hash = this._persistedOperations[operationName];
+        const key = this._getKey(operationName, variables);
+        const operationVariables = (0, helpers_1.variableObject)(variables);
+        (0, errors_1.assertOperationHash)(sha256Hash, operationType, operationName);
+        const inFlight = this._inFlight[key];
+        if (operationType === 'query' && inFlight) {
+            return inFlight;
+        }
+        const operationInFlight = this._fetch({
+            query: '',
+            operationName,
+            variables: operationVariables,
+            extensions: {
+                persistedQuery: { version: 1, sha256Hash },
+            },
         });
-        //
-        if (operationType === 'query' && (added || modified)) {
-            c.operations[key] = {
-                stale: false,
+        this._inFlight[key] = operationInFlight;
+        const operationResult = await operationInFlight.finally(() => {
+            delete this._inFlight[key];
+        });
+        if (operationResult.fetchError) {
+            return operationResult;
+        }
+        const meta = operationResult.extensions?.['graphqlNormalizeMeta'] ??
+            this._getMeta(operationName);
+        // Ensure we have metadata to be able to normalize the operation in our cache
+        if (!meta) {
+            throw new errors_1.MissingMetaError(operationName);
+        }
+        const lastCache = this._cacheStore;
+        this._cacheStore = (0, immer_1.produce)(this._cacheStore, (c) => {
+            const currentResult = c.operations[key];
+            const { added, modified, result } = (0, graphql_normalize_1.graphqlNormalize)({
+                action: 'write',
+                operationResult,
                 meta,
-                operationName,
+                cache: c.fields,
                 variableValues: operationVariables,
-                data: result,
-                errors: operationResult.errors,
-                extensions: operationResult.extensions,
-                operationType: operationType,
-            };
-        }
-        // If we've modified anything in the cache, we also need to update any
-        // mounted queries
-        if (modified) {
-            for (const [k, val] of Object.entries(c.operations)) {
-                if (k === key || val.operationType !== 'query') {
-                    continue;
-                }
-                //
-                if (val.data) {
-                    const { result } = (0, graphql_normalize_1.graphqlNormalize)({
-                        action: 'read',
-                        currentResult: val.data,
-                        cache: c.fields,
-                        meta: val.meta,
-                        variableValues: val.variableValues,
-                    });
-                    if (result !== val) {
-                        val.data = result;
+                currentResult,
+                isEqual: lodash_isequal_1.default,
+            });
+            //
+            if (operationType === 'query' && (added || modified)) {
+                c.operations[key] = {
+                    stale: false,
+                    meta,
+                    operationName,
+                    variableValues: operationVariables,
+                    data: result,
+                    errors: operationResult.errors,
+                    extensions: operationResult.extensions,
+                    operationType: operationType,
+                };
+            }
+            // If we've modified anything in the cache, we also need to update any
+            // mounted queries
+            if (modified) {
+                for (const [k, val] of Object.entries(c.operations)) {
+                    if (k === key || val.operationType !== 'query') {
+                        continue;
+                    }
+                    //
+                    if (val.data) {
+                        const { result } = (0, graphql_normalize_1.graphqlNormalize)({
+                            action: 'read',
+                            currentResult: val.data,
+                            cache: c.fields,
+                            meta: val.meta,
+                            variableValues: val.variableValues,
+                        });
+                        if (result !== val) {
+                            val.data = result;
+                        }
                     }
                 }
             }
-        }
-    }), "f");
-    // If this was a mutation, we need to go through and determine if we need to mark
-    // any Queries as "stale", or eagerly refetch any of the queries
-    if (operationType === 'mutation') {
-        const toInvalidate = new Set();
-        const mutationName = operationName;
-        const mutationFn = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_mutationInvalidation, "f")?.[mutationName];
-        for (const [operationKey, operation] of Object.entries(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations)) {
-            if (operation.operationType !== 'query') {
-                continue;
-            }
-            const queryName = operation.operationName;
-            const queryVariables = operation.variableValues;
-            const queryFn = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_queryInvalidation, "f")[queryName];
-            if (queryFn?.(mutationName, operationVariables, queryVariables)) {
-                toInvalidate.add(operationKey);
+        });
+        // If this was a mutation, we need to go through and determine if we need to mark
+        // any Queries as "stale", or eagerly refetch any of the queries
+        if (operationType === 'mutation') {
+            const toInvalidate = new Set();
+            const mutationName = operationName;
+            const mutationFn = this._mutationInvalidation?.[mutationName];
+            for (const [operationKey, operation] of Object.entries(this._cacheStore.operations)) {
+                if (operation.operationType !== 'query') {
+                    continue;
+                }
+                const queryName = operation.operationName;
+                const queryVariables = operation.variableValues;
+                const queryFn = this._queryInvalidation[queryName];
+                if (queryFn?.(mutationName, operationVariables, queryVariables)) {
+                    toInvalidate.add(operationKey);
+                }
+                if (mutationFn?.(queryName, queryVariables, operationVariables)) {
+                    toInvalidate.add(operationKey);
+                }
             }
-            if (mutationFn?.(queryName, queryVariables, operationVariables)) {
-                toInvalidate.add(operationKey);
+            if (toInvalidate.size) {
+                this._cacheStore = (0, immer_1.produce)(this._cacheStore, (o) => {
+                    for (const key of toInvalidate) {
+                        const op = o.operations[key];
+                        if (op)
+                            op.stale = true;
+                    }
+                });
             }
         }
-        if (toInvalidate.size) {
-            tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, (0, immer_1.produce)(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f"), (o) => {
-                for (const key of toInvalidate) {
-                    const op = o.operations[key];
-                    if (op)
-                        op.stale = true;
-                }
-            }), "f");
-        }
-    }
-    // If we've updated any operations, we need to update any subscribed components
-    if (lastCache.operations !== tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations) {
-        for (const [key, val] of Object.entries(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations)) {
-            if (tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key] !== lastCache.operations[key]) {
-                if (tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_subscribedQueries, "f")[key]) {
-                    tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_subscribedQueries, "f")[key]?.forEach((o) => o.onUpdate(val));
+        // If we've updated any operations, we need to update any subscribed components
+        if (lastCache.operations !== this._cacheStore.operations) {
+            for (const [key, val] of Object.entries(this._cacheStore.operations)) {
+                if (this._cacheStore.operations[key] !== lastCache.operations[key]) {
+                    if (this._subscribedQueries[key]) {
+                        this._subscribedQueries[key]?.forEach((o) => o.onUpdate(val));
+                    }
                 }
             }
         }
+        if (operationType === 'query') {
+            return this._cacheStore.operations[key];
+        }
+        return operationResult;
     }
-    if (operationType === 'query') {
-        return tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key];
-    }
-    return operationResult;
-}, _GraphQLQueryCache_getMeta = function _GraphQLQueryCache_getMeta(opName) {
-    const meta = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").meta[opName] ?? tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_configMeta, "f")?.[opName];
-    if (!meta) {
-        throw new errors_1.MissingMetaError(opName);
+    _getMeta(opName) {
+        const meta = this._cacheStore.meta[opName] ?? this._configMeta?.[opName];
+        if (!meta) {
+            throw new errors_1.MissingMetaError(opName);
+        }
+        return meta;
     }
-    return meta;
-}, _GraphQLQueryCache_fetch = 
-/**
- * Handles "fetch", ensuring we catch network errors and handle non-200
- * responses properly so we're able to forward these on in a normalized fashion
- */
-async function _GraphQLQueryCache_fetch(body) {
-    let result;
-    try {
-        result = await tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_makeFetch).call(this, body);
-        if (result.status === 200) {
-            const json = (await result.json());
-            return json;
+    /**
+     * Handles "fetch", ensuring we catch network errors and handle non-200
+     * responses properly so we're able to forward these on in a normalized fashion
+     */
+    async _fetch(body) {
+        let result;
+        try {
+            result = await this._makeFetch(body);
+            if (result.status === 200) {
+                const json = (await result.json());
+                return json;
+            }
+            else {
+                return {
+                    fetchError: {
+                        name: 'ResponseError',
+                        message: await result.text(),
+                        status: result.status,
+                        statusText: result.statusText,
+                    },
+                };
+            }
         }
-        else {
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
             return {
                 fetchError: {
-                    name: 'ResponseError',
-                    message: await result.text(),
-                    status: result.status,
-                    statusText: result.statusText,
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                    status: result?.status,
+                    statusText: result?.statusText,
                 },
             };
         }
     }
-    catch (e) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        return {
-            fetchError: {
-                name: error.name,
-                message: error.message,
-                stack: error.stack,
-                status: result?.status,
-                statusText: result?.statusText,
+    _makeFetch(body) {
+        const reqInit = {
+            method: 'POST',
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
             },
         };
+        if (this._fetcher) {
+            return this._fetcher(this._endpoint, reqInit);
+        }
+        return fetch(this._endpoint, reqInit);
+    }
+    /**
+     * Determine whether we should refetch the query based on the
+     * current value of the query, and the options passed to the query
+     */
+    _shouldRefetchQuery() {
+        //
     }
-}, _GraphQLQueryCache_makeFetch = function _GraphQLQueryCache_makeFetch(body) {
-    const reqInit = {
-        method: 'POST',
-        body: JSON.stringify(body),
-        headers: {
-            'content-type': 'application/json',
-        },
-    };
-    if (tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_fetcher, "f")) {
-        return tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_fetcher, "f").call(this, tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_endpoint, "f"), reqInit);
+    /**
+     * "Garbage collection" for existing operations. If they have
+     * a TTL or are invalidated by other operations, and aren't mounted,
+     * then we can go ahead and sweep out any data we might have for them
+     */
+    _gcOperations() {
+        //
     }
-    return fetch(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_endpoint, "f"), reqInit);
-}, _GraphQLQueryCache_shouldRefetchQuery = function _GraphQLQueryCache_shouldRefetchQuery() {
-    //
-}, _GraphQLQueryCache_gcOperations = function _GraphQLQueryCache_gcOperations() {
-    //
-};
+}
+exports.GraphQLQueryCache = GraphQLQueryCache;
 function unwrapMeta(meta) {
     if (!meta)
         return meta;