graphql-persisted 0.0.1

package/README.md

@@ -0,0 +1,54 @@
+## graphql-persisted
+
+Note: This package is experimental and not yet intended for any sort of production usage.
+Still designing the APIs through real world use & experimentation, subject to breakage prior to 1.0
+
+An opinionated GraphQL client, initially focused on:
+
+- Goals:
+  - Server Persisted Queries
+  - Type-safety out of the box
+  - Minimizing GraphQL in the client (no client-side dependency on the "graphql" package)
+  - Performance, simplicity
+- Non-Goals:
+  - Supporting multiple GraphQL endpoints in the same application
+
+Built atop [graphql-normalize](https://github.com/tgriesser/graphql-normalize)
+
+### GraphQLQueryCache API:
+
+```ts
+class GraphQLQueryCache {
+  //
+}
+```
+
+### Queries:
+
+```ts
+const { data } = usePersistedQuery('QueryName', { variables })
+```
+
+```ts
+usePreloadedPersistedQuery('QueryName', { variables })
+```
+
+### Mutations:
+
+```ts
+const { execute } = usePersistedMutation('MutationName')
+```
+
+### Subscriptions:
+
+TODO
+
+### Fragments
+
+```ts
+const unwrappedData = unwrapFragment('FragName', data)
+```
+
+# License
+
+MIT

package/cjs/GraphQLQueryCache.d.ts

@@ -0,0 +1,62 @@
+import type { GraphQLCacheShape, GraphQLMutationResult, GraphQLOperationResult, GraphQLQueryCacheConfig, GraphQLQueryResult, InvalidateQueryArgs, MaybePromise, ExecutionOptions, 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;
+    constructor(config: GraphQLQueryCacheConfig);
+    /**
+     * Invalidates a query by name or predicate fn
+     */
+    invalidateQuery(toInvalidate: InvalidateQueryArgs): void;
+    /**
+     * Invalidates a query by name or predicate fn
+     */
+    refetchQuery(toRefetch: InvalidateQueryArgs): void;
+    /**
+     * JSON.stringify(queryCache) produces the data we need
+     * to rehydrate the Client
+     */
+    toJSON(): GraphQLCacheShape;
+    /**
+     * Attempts to read a query from the cache, returning undefined
+     * if we are unable to for any reason. Used in initial hook execution
+     * where we don't want any side-effects, incase we're doing SSR
+     */
+    tryReadQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): GraphQLOperationResult<Q> | undefined;
+    /**
+     * Reads the query from the cache. Throws an error if we are unable
+     * to read the data, due to an incomplete result or lack of operation
+     * metadata
+     */
+    readQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): GraphQLOperationResult<Q>;
+    /**
+     * Reads the query from the cache if any of the following conditions are met:
+     *  a) We already have the result of this query in the operation cache
+     *  b) We have the necessary metadata, as well as all of the necessary fields info to complete
+     *     this query from the field cache
+     */
+    readOrFetchQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): GraphQLOperationResult<Q> | Promise<GraphQLOperationResult<Q>>;
+    /**
+     * Loads the query if it's not already in the cache,
+     * useful when hydrating the cache outside of a component
+     */
+    preloadQuery<Q extends keyof GraphQLQuery.QueryRegistry>(queryName: Q, options: PreloadQueryOptions<Q>): MaybePromise<GraphQLOperationResult<Q>>;
+    fetchQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): Promise<GraphQLOperationResult<Q>>;
+    /**
+     * Executes a mutation, returning the result of that mutation
+     */
+    executeMutation<M extends keyof GraphQLQuery.MutationRegistry>(mutationName: M, variables: SerializedVariables | object, options?: ExecutionOptions): Promise<GraphQLMutationResult<M>>;
+    /**
+     * Executes a query, returning the result of that query
+     */
+    executeQuery<Q extends keyof GraphQLQuery.QueryRegistry>(queryName: Q, variables: SerializedVariables | GraphQLQuery.OperationVariables[Q]): Promise<GraphQLQueryResult<Q>>;
+    executeSubscription(): Promise<void>;
+    /**
+     * "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;
+}

package/cjs/GraphQLQueryCache.js

@@ -0,0 +1,456 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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_shouldRefetchQuery, _GraphQLQueryCache_gcOperations;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLQueryCache = void 0;
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+const graphql_normalize_1 = require("graphql-normalize");
+const immer_1 = require("immer");
+const errors_1 = require("./errors");
+const helpers_1 = require("./helpers");
+/**
+ * Manages the cached normalized state, and the execution of
+ * data accessed by different components
+ */
+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, {}
+        // 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);
+        // 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);
+        /**
+         * 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 || fetch, "f");
+        __classPrivateFieldSet(this, _GraphQLQueryCache_endpoint, config.endpoint || `${window.location.origin}/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, (0, immer_1.produce)(config.hydratedCache ?? {
+            meta: {},
+            fields: {},
+            operations: {},
+        }, noop), "f");
+    }
+    /**
+     * Invalidates a query by name or predicate fn
+     */
+    invalidateQuery(toInvalidate) {
+        (0, immer_1.produce)(__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+            //
+        });
+    }
+    /**
+     * Invalidates a query by name or predicate fn
+     */
+    refetchQuery(toRefetch) {
+        (0, immer_1.produce)(__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+            //
+        });
+    }
+    /**
+     * JSON.stringify(queryCache) produces the data we need
+     * to rehydrate the Client
+     */
+    toJSON() {
+        const { fields, operations, meta } = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
+        return {
+            fields,
+            operations: operations,
+            meta: meta,
+        };
+    }
+    // /**
+    //  * Whether we've fetched the query in the cache yet
+    //  */
+    // hasQuery<Q extends keyof GraphQLQuery.QueryRegistry>(
+    //   queryName: Q,
+    //   variable: SerializedVariables | GraphQLQuery.OperationVariables[Q]
+    // ) {
+    //   // Object.values(this.#cacheStore.operations).find((o) => {
+    //   //   return o.operationType === 'query' && o
+    //   // })
+    // }
+    /**
+     * Attempts to read a query from the cache, returning undefined
+     * if we are unable to for any reason. Used in initial hook execution
+     * where we don't want any side-effects, incase we're doing SSR
+     */
+    tryReadQuery(args) {
+        try {
+            return this.readQuery(args);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Reads the query from the cache. Throws an error if we are unable
+     * to read the data, due to an incomplete result or lack of operation
+     * metadata
+     */
+    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];
+        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 { result } = (0, graphql_normalize_1.graphqlNormalize)({
+            action: 'read',
+            variableValues: typeof variables === 'string' ? JSON.parse(variables) : variables,
+            meta: meta,
+            cache: __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").fields,
+            isEqual: lodash_isequal_1.default,
+        });
+        return {
+            data: result,
+        };
+    }
+    /**
+     * Reads the query from the cache if any of the following conditions are met:
+     *  a) We already have the result of this query in the operation cache
+     *  b) We have the necessary metadata, as well as all of the necessary fields info to complete
+     *     this query from the field cache
+     */
+    readOrFetchQuery(args) {
+        // If we don't have the metadata for the Query yet, we won't know how
+        // to read it from the cache. In this case we first need to fetch the query
+        // and check for the meta in the extensions to know how to normalize it
+        try {
+            const readResult = this.readQuery(args);
+            if (readResult) {
+                this.fetchQuery(args);
+            }
+            return readResult;
+        }
+        catch {
+            return this.fetchQuery(args);
+        }
+    }
+    /**
+     * Loads the query if it's not already in the cache,
+     * useful when hydrating the cache outside of a component
+     */
+    preloadQuery(queryName, options) {
+        const { blockIfStale = true } = options;
+        const variables = (0, helpers_1.variableString)(options.variables ?? {});
+        const sha256Hash = __classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[queryName];
+        const key = `${sha256Hash}:${variables}`;
+        const operation = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").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: {} });
+            return operation && blockIfStale === false ? operation : inFlight;
+        }
+        return operation;
+    }
+    fetchQuery(args) {
+        return __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_executeOperation).call(this, '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);
+    }
+    /**
+     * 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);
+    }
+    async executeSubscription() {
+        throw new Error('Not yet supported');
+    }
+    /**
+     * "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(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] = []));
+        queries.push(args);
+        // Now that the component is subscribed, we can begin fetching,
+        // refetching, and otherwise managing the query
+        if (!queryResult) {
+            //
+        }
+        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 = __classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[operationName];
+    return `${sha256Hash}:${(0, helpers_1.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 = (0, helpers_1.variableObject)(variables);
+    (0, errors_1.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 errors_1.MissingMetaError(operationName);
+    }
+    const lastCache = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
+    __classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, (0, immer_1.produce)(__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,
+        });
+        //
+        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 = __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 (mutationFn?.(queryName, queryVariables, operationVariables)) {
+                toInvalidate.add(operationKey);
+            }
+        }
+        if (toInvalidate.size) {
+            __classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, (0, immer_1.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 (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 errors_1.MissingMetaError(opName);
+    }
+    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 fetch(__classPrivateFieldGet(this, _GraphQLQueryCache_endpoint, "f"), {
+            method: 'POST',
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        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,
+                },
+            };
+        }
+    }
+    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,
+            },
+        };
+    }
+}, _GraphQLQueryCache_shouldRefetchQuery = function _GraphQLQueryCache_shouldRefetchQuery() {
+    //
+}, _GraphQLQueryCache_gcOperations = function _GraphQLQueryCache_gcOperations() {
+    //
+};
+function unwrapMeta(meta) {
+    if (!meta)
+        return meta;
+    const o = {};
+    for (const [key, val] of Object.entries(meta)) {
+        if (typeof val === 'string') {
+            o[key] = isBase64(val) ? JSON.parse(fromBase64(val)) : JSON.parse(val);
+        }
+        else {
+            o[key] = val;
+        }
+    }
+    return o;
+}
+function isBase64(str) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(str, 'base64').toString('base64') === str;
+    }
+    try {
+        window.btoa(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function fromBase64(str) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(str, 'base64').toString('utf8');
+    }
+    return window.atob(str);
+}
+function noop() { }

package/cjs/context.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { GraphQLQueryCache } from './GraphQLQueryCache.js';
+/**
+ * Provides an initialized `GraphQLQueryCache` for use by hooks throughout
+ * the rest of the application.
+ *
+ * @example
+ *  <GraphQLQueryProvider cache={cache}>
+ *    <App />
+ *  </GraphQLQueryProvider>
+ */
+export declare const GraphQLQueryProvider: React.FC<{
+    cache: GraphQLQueryCache;
+    children: React.ReactNode | React.ReactNode[];
+}>;
+/**
+ * Hook returning the initialized GraphQL Query Cache
+ *
+ * Throws if accessed outside of a `GraphQLQueryProvider`
+ */
+export declare const useGraphQLQueryCache: () => GraphQLQueryCache;

package/cjs/context.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGraphQLQueryCache = exports.GraphQLQueryProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const GraphQLQueryContext = (0, react_1.createContext)(null);
+/**
+ * Provides an initialized `GraphQLQueryCache` for use by hooks throughout
+ * the rest of the application.
+ *
+ * @example
+ *  <GraphQLQueryProvider cache={cache}>
+ *    <App />
+ *  </GraphQLQueryProvider>
+ */
+const GraphQLQueryProvider = ({ cache, children }) => {
+    return (0, jsx_runtime_1.jsx)(GraphQLQueryContext.Provider, { value: cache, children: children });
+};
+exports.GraphQLQueryProvider = GraphQLQueryProvider;
+/**
+ * Hook returning the initialized GraphQL Query Cache
+ *
+ * Throws if accessed outside of a `GraphQLQueryProvider`
+ */
+const useGraphQLQueryCache = () => {
+    const ctx = (0, react_1.useContext)(GraphQLQueryContext);
+    if (!ctx) {
+        throw new Error(`useGraphQLQueryCache must be nested inside a GraphQLQueryProvider`);
+    }
+    return ctx;
+};
+exports.useGraphQLQueryCache = useGraphQLQueryCache;

package/cjs/errors.d.ts

@@ -0,0 +1,19 @@
+export declare class GraphQLQueryError extends Error {
+}
+/**
+ * Thrown in situations where we are expecting graphql-normalize metadata
+ * to be available, but it isn't yet available.
+ */
+export declare class MissingMetaError extends Error {
+    constructor(queryName: string);
+}
+export declare class UnknownOperationError extends Error {
+    constructor(operationName: string, operationType: string);
+}
+export declare class MissingNormalizeMetaError extends Error {
+    constructor(operationName: string, operationType: string);
+}
+export declare class ExpectedPreloadedQueryError extends GraphQLQueryError {
+    constructor(queryName: string);
+}
+export declare function assertOperationHash(hash: string | undefined, operationType: 'query' | 'mutation' | 'subscription', operationName: string): void;