graphql-persisted 0.0.5 → 0.0.6

package/mjs/GraphQLQueryCache.js

@@ -1,5 +1,3 @@
-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;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import isEqual from 'lodash.isequal';
 import { graphqlNormalize } from 'graphql-normalize';
 import { produce } from 'immer';
@@ -11,67 +9,38 @@ import { variableObject, variableString } from './helpers';
  */
 export 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
-        __classPrivateFieldSet(this, _GraphQLQueryCache_fetcher, config.fetcher, "f");
-        __classPrivateFieldSet(this, _GraphQLQueryCache_endpoint, config.endpoint || `/graphql`, "f");
-        __classPrivateFieldSet(this, _GraphQLQueryCache_persistedOperations, config.persistedOperations, "f");
-        __classPrivateFieldSet(this, _GraphQLQueryCache_persistedDocuments, config.persistedDocuments, "f");
-        __classPrivateFieldSet(this, _GraphQLQueryCache_configMeta, unwrapMeta(config.meta), "f");
-        __classPrivateFieldSet(this, _GraphQLQueryCache_queryInvalidation, config.queryInvalidation ?? {}, "f");
-        __classPrivateFieldSet(this, _GraphQLQueryCache_mutationInvalidation, config.mutationInvalidation ?? {}, "f");
-        __classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, 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 = produce(config.hydratedCache ?? {
             meta: {},
             fields: {},
             operations: {},
-        }, noop), "f");
+        }, noop);
     }
     /**
      * Invalidates a query by name or predicate fn
      */
     invalidateQuery(toInvalidate) {
-        produce(__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+        produce(this._runtimeCache, () => {
             //
         });
     }
@@ -79,7 +48,7 @@ export class GraphQLQueryCache {
      * Invalidates a query by name or predicate fn
      */
     refetchQuery(toRefetch) {
-        produce(__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+        produce(this._runtimeCache, () => {
             //
         });
     }
@@ -88,7 +57,7 @@ export class GraphQLQueryCache {
      * to rehydrate the Client
      */
     toJSON() {
-        const { fields, operations, meta } = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
+        const { fields, operations, meta } = this._cacheStore;
         return {
             fields,
             operations: operations,
@@ -102,7 +71,7 @@ export 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
     //   // })
     // }
@@ -126,19 +95,19 @@ export class GraphQLQueryCache {
      */
     readQuery(args) {
         const { queryName, variables, options } = args;
-        const key = __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, queryName, variables);
-        const op = __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 = __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getMeta).call(this, queryName);
+        const meta = this._getMeta(queryName);
         const { result } = graphqlNormalize({
             action: 'read',
             variableValues: typeof variables === 'string' ? JSON.parse(variables) : variables,
             meta: meta,
-            cache: __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").fields,
+            cache: this._cacheStore.fields,
             isEqual,
         });
         return {
@@ -173,9 +142,9 @@ export class GraphQLQueryCache {
     preloadQuery(queryName, options) {
         const { blockIfStale = true } = options;
         const variables = variableString(options.variables ?? {});
-        const sha256Hash = __classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[queryName];
+        const sha256Hash = this._persistedOperations[queryName];
         const key = `${sha256Hash}:${variables}`;
-        const operation = __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: {} });
@@ -184,23 +153,27 @@ export class GraphQLQueryCache {
         return operation;
     }
     fetchQuery(args) {
-        return __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 __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 __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}:${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
@@ -209,207 +182,216 @@ export class GraphQLQueryCache {
     subscribeToQuery(args) {
         var _a;
         const { queryName, queryResult, variables, onUpdate, options } = args;
-        const key = __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, queryName, variables);
-        const queries = ((_a = __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);
         };
     }
-}
-_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 = __classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[operationName];
-    return `${sha256Hash}:${variableString(variables)}`;
-}, _GraphQLQueryCache_executeOperation = async function _GraphQLQueryCache_executeOperation(operationType, operationName, variables) {
-    const sha256Hash = __classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[operationName];
-    const key = __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, operationName, variables);
-    const operationVariables = variableObject(variables);
-    assertOperationHash(sha256Hash, operationType, operationName);
-    const inFlight = __classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key];
-    if (operationType === 'query' && inFlight) {
-        return inFlight;
-    }
-    const operationInFlight = __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_fetch).call(this, {
-        query: '',
-        operationName,
-        variables: operationVariables,
-        extensions: {
-            persistedQuery: { version: 1, sha256Hash },
-        },
-    });
-    __classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key] = operationInFlight;
-    const operationResult = await operationInFlight.finally(() => {
-        delete __classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key];
-    });
-    if (operationResult.fetchError) {
-        return operationResult;
-    }
-    const meta = operationResult.extensions?.['graphqlNormalizeMeta'] ??
-        __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 MissingMetaError(operationName);
-    }
-    const lastCache = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
-    __classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, produce(__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f"), (c) => {
-        const currentResult = c.operations[key];
-        const { added, modified, result } = graphqlNormalize({
-            action: 'write',
-            operationResult,
-            meta,
-            cache: c.fields,
-            variableValues: operationVariables,
-            currentResult,
-            isEqual,
+    async _executeOperation(operationType, operationName, variables) {
+        const sha256Hash = this._persistedOperations[operationName];
+        const key = this._getKey(operationName, variables);
+        const operationVariables = variableObject(variables);
+        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 MissingMetaError(operationName);
+        }
+        const lastCache = this._cacheStore;
+        this._cacheStore = produce(this._cacheStore, (c) => {
+            const currentResult = c.operations[key];
+            const { added, modified, result } = 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 } = graphqlNormalize({
-                        action: 'read',
-                        currentResult: val.data,
-                        cache: c.fields,
-                        meta: val.meta,
-                        variableValues: val.variableValues,
-                    });
-                    if (result !== val) {
-                        val.data = result;
+                currentResult,
+                isEqual,
+            });
+            //
+            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 } = 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 = __classPrivateFieldGet(this, _GraphQLQueryCache_mutationInvalidation, "f")?.[mutationName];
-        for (const [operationKey, operation] of Object.entries(__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations)) {
-            if (operation.operationType !== 'query') {
-                continue;
-            }
-            const queryName = operation.operationName;
-            const queryVariables = operation.variableValues;
-            const queryFn = __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 = produce(this._cacheStore, (o) => {
+                    for (const key of toInvalidate) {
+                        const op = o.operations[key];
+                        if (op)
+                            op.stale = true;
+                    }
+                });
             }
         }
-        if (toInvalidate.size) {
-            __classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, produce(__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 !== __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations) {
-        for (const [key, val] of Object.entries(__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations)) {
-            if (__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key] !== lastCache.operations[key]) {
-                if (__classPrivateFieldGet(this, _GraphQLQueryCache_subscribedQueries, "f")[key]) {
-                    __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 __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key];
-    }
-    return operationResult;
-}, _GraphQLQueryCache_getMeta = function _GraphQLQueryCache_getMeta(opName) {
-    const meta = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").meta[opName] ?? __classPrivateFieldGet(this, _GraphQLQueryCache_configMeta, "f")?.[opName];
-    if (!meta) {
-        throw new MissingMetaError(opName);
+    _getMeta(opName) {
+        const meta = this._cacheStore.meta[opName] ?? this._configMeta?.[opName];
+        if (!meta) {
+            throw new 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 __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);
     }
-}, _GraphQLQueryCache_makeFetch = function _GraphQLQueryCache_makeFetch(body) {
-    const reqInit = {
-        method: 'POST',
-        body: JSON.stringify(body),
-        headers: {
-            'content-type': 'application/json',
-        },
-    };
-    if (__classPrivateFieldGet(this, _GraphQLQueryCache_fetcher, "f")) {
-        return __classPrivateFieldGet(this, _GraphQLQueryCache_fetcher, "f").call(this, __classPrivateFieldGet(this, _GraphQLQueryCache_endpoint, "f"), reqInit);
+    /**
+     * Determine whether we should refetch the query based on the
+     * current value of the query, and the options passed to the query
+     */
+    _shouldRefetchQuery() {
+        //
     }
-    return fetch(__classPrivateFieldGet(this, _GraphQLQueryCache_endpoint, "f"), reqInit);
-}, _GraphQLQueryCache_shouldRefetchQuery = function _GraphQLQueryCache_shouldRefetchQuery() {
-    //
-}, _GraphQLQueryCache_gcOperations = function _GraphQLQueryCache_gcOperations() {
-    //
-};
+    /**
+     * "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() {
+        //
+    }
+}
 function unwrapMeta(meta) {
     if (!meta)
         return meta;

package/mjs/graphqlHooks.js

@@ -62,6 +62,7 @@ export function usePersistedQuery(queryName, options) {
     // or it is refetched
     useEffect(() => {
         return cache.subscribeToQuery({
+            queryResult,
             queryName,
             variables: variableString,
             onUpdate: setQueryResult,
@@ -86,8 +87,15 @@ export function useLazyPersistedQuery(query) {
     const [fetched, setIsFetched] = useState(false);
     const [loading, setIsLoading] = useState(false);
     const loadQuery = useCallback((variables) => {
-        return new Promise((resolve) => {
-            cache.readOrFetchQuery({ queryName: query, variables: serializeVariables(variables), options: {} });
+        return new Promise((resolve, reject) => {
+            const result = cache.readOrFetchQuery({
+                queryName: query,
+                variables: serializeVariables(variables),
+                options: {},
+            });
+            // if ('then' in result && typeof result.then === 'function') {
+            //   Promise.resolve(result).then(resolve, reject)
+            // }
         });
     }, [cache, query]);
     const errors = undefined;

package/mjs/types.d.ts

@@ -167,7 +167,7 @@ export interface SubscribeToQueryArgs<Q extends keyof GraphQLQuery.QueryRegistry
     /**
      * The result of readQuery, used to check whether the query is stale
      */
-    queryResult?: GraphQLQuery.QueryRegistry[Q];
+    queryResult?: GraphQLOperationResult<Q>;
     /**
      * Invoked when the values for this query are updated
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-persisted",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "WIP: An Opinionated GraphQL Query Library, with a focus on fully persisted queries",
   "keywords": [
     "graphql",
@@ -29,7 +29,7 @@
   ],
   "dependencies": {
     "tslib": "^2.5.0",
-    "graphql-normalize": "^0.2.1",
+    "graphql-normalize": "^0.2.2",
     "lodash.isequal": "^4.5.0"
   },
   "devDependencies": {