graphql-persisted 0.0.1

package/mjs/GraphQLQueryCache.js

@@ -0,0 +1,449 @@
+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 _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;
+import isEqual from 'lodash.isequal';
+import { graphqlNormalize } from 'graphql-normalize';
+import { produce } from 'immer';
+import { MissingMetaError, assertOperationHash } from './errors';
+import { variableObject, variableString } from './helpers';
+/**
+ * Manages the cached normalized state, and the execution of
+ * data accessed by different components
+ */
+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, {}
+        // 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, produce(config.hydratedCache ?? {
+            meta: {},
+            fields: {},
+            operations: {},
+        }, noop), "f");
+    }
+    /**
+     * Invalidates a query by name or predicate fn
+     */
+    invalidateQuery(toInvalidate) {
+        produce(__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+            //
+        });
+    }
+    /**
+     * Invalidates a query by name or predicate fn
+     */
+    refetchQuery(toRefetch) {
+        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 } = graphqlNormalize({
+            action: 'read',
+            variableValues: typeof variables === 'string' ? JSON.parse(variables) : variables,
+            meta: meta,
+            cache: __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").fields,
+            isEqual,
+        });
+        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 = 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);
+        };
+    }
+}
+_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,
+        });
+        //
+        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 (mutationFn?.(queryName, queryVariables, operationVariables)) {
+                toInvalidate.add(operationKey);
+            }
+        }
+        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 (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);
+    }
+    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/mjs/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/mjs/context.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const GraphQLQueryContext = createContext(null);
+/**
+ * Provides an initialized `GraphQLQueryCache` for use by hooks throughout
+ * the rest of the application.
+ *
+ * @example
+ *  <GraphQLQueryProvider cache={cache}>
+ *    <App />
+ *  </GraphQLQueryProvider>
+ */
+export const GraphQLQueryProvider = ({ cache, children }) => {
+    return _jsx(GraphQLQueryContext.Provider, { value: cache, children: children });
+};
+/**
+ * Hook returning the initialized GraphQL Query Cache
+ *
+ * Throws if accessed outside of a `GraphQLQueryProvider`
+ */
+export const useGraphQLQueryCache = () => {
+    const ctx = useContext(GraphQLQueryContext);
+    if (!ctx) {
+        throw new Error(`useGraphQLQueryCache must be nested inside a GraphQLQueryProvider`);
+    }
+    return ctx;
+};

package/mjs/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;

package/mjs/errors.js

@@ -0,0 +1,31 @@
+export class GraphQLQueryError extends Error {
+}
+/**
+ * Thrown in situations where we are expecting graphql-normalize metadata
+ * to be available, but it isn't yet available.
+ */
+export class MissingMetaError extends Error {
+    constructor(queryName) {
+        super(`Cannot readQuery('${queryName}') without graphql-normalize metadata.`);
+    }
+}
+export class UnknownOperationError extends Error {
+    constructor(operationName, operationType) {
+        super(`Unknown ${operationType} operation ${operationName}, not found in the hash of operations`);
+    }
+}
+export class MissingNormalizeMetaError extends Error {
+    constructor(operationName, operationType) {
+        super(`extensions.graphqlNormalizeMeta is was expected for the ${operationName} ${operationType}.\n You must configure your GraphQLQueryCache with the "meta" property, or add this as part of your repsonse payload`);
+    }
+}
+export class ExpectedPreloadedQueryError extends GraphQLQueryError {
+    constructor(queryName) {
+        super(`Expected query ${queryName} to be preloaded with preloadQuery`);
+    }
+}
+export function assertOperationHash(hash, operationType, operationName) {
+    if (!hash) {
+        throw new UnknownOperationError(operationName, operationType);
+    }
+}

package/mjs/fragmentData.d.ts

@@ -0,0 +1,12 @@
+export type FragmentType<Frag extends keyof GraphQLQuery.FragmentRegistry> = GraphQLQuery.FragmentRegistry[Frag] extends infer FragType ? FragType extends {
+    ' $fragmentName'?: infer TKey;
+} ? TKey extends string ? {
+    ' $fragmentRefs'?: {
+        [key in TKey]: FragType;
+    };
+} : never : never : never;
+export declare function unwrapFragment<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: FragmentType<Frag>): GraphQLQuery.FragmentRegistry[Frag];
+export declare function unwrapFragment<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: FragmentType<Frag> | null | undefined): GraphQLQuery.FragmentRegistry[Frag] | null | undefined;
+export declare function unwrapFragment<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: ReadonlyArray<FragmentType<Frag>>): ReadonlyArray<GraphQLQuery.FragmentRegistry[Frag]>;
+export declare function unwrapFragment<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: ReadonlyArray<FragmentType<Frag>> | null | undefined): ReadonlyArray<GraphQLQuery.FragmentRegistry[Frag]> | null | undefined;
+export declare function castFragmentData<F extends keyof GraphQLQuery.FragmentRegistry, FT extends GraphQLQuery.FragmentRegistry[F]>(_fragmentName: F, data: FT): FragmentType<F>;

package/mjs/fragmentData.js

@@ -0,0 +1,6 @@
+export function unwrapFragment(_fragmentName, fragmentType) {
+    return fragmentType;
+}
+export function castFragmentData(_fragmentName, data) {
+    return data;
+}

package/mjs/graphqlHooks.d.ts

@@ -0,0 +1,48 @@
+import type { GraphQLPreloadedQueryResult, GraphQLQueryLazyResult, GraphQLQueryResult, ExecutionOptions, PersistedQueryOptions, QueryVariables, GraphQLMutationResult, ExecuteMutationOptions } from './types';
+/**
+ * Loads a preloaded query. Like useQuery, except it throws if the
+ * query does not already exist in the cache.
+ *
+ * This hook keeps track of the value of the last render, so we're always guaranteed
+ * to have data here, even if it's potentially stale.
+ */
+export declare const usePreloadedPersistedQuery: <QueryName extends never>(query: QueryName, options: PersistedQueryOptions & QueryVariables<QueryName>) => GraphQLPreloadedQueryResult<QueryName>;
+/**
+ * Retrieves the persisted query from the cache,
+ * creating it from the cache if we don't have a mounted version
+ *
+ * Fetches the query if:
+ *
+ * 1. We don't already have the operation fetched in the cache
+ * 2. The query is considered stale based on:
+ *    a) The TTL setting
+ *    b) A mutation which invalidates the query
+ */
+export declare const usePersistedQuery: <QueryName extends never>(queryName: QueryName, options: PersistedQueryOptions & QueryVariables<QueryName>) => GraphQLQueryResult<QueryName>;
+/**
+ * TODO: Not working yet
+ * Creates a container for a query that isn't fetched immediately,
+ * but provides a loadQuery function to call
+ */
+export declare const useLazyPersistedQuery: <QueryName extends never>(query: QueryName) => GraphQLQueryLazyResult<QueryName>;
+/**
+ * Executes a persisted mutation, keeping track of mutations in-flight to ensure
+ * we don't execute the same mutation multiple times with the same values
+ * in the same component
+ */
+export declare const usePersistedMutation: <MutationName extends never>(mutationName: MutationName, options?: ExecutionOptions) => {
+    execute: (vars: GraphQLQuery.OperationVariables[MutationName], opts?: ExecuteMutationOptions) => Promise<GraphQLMutationResult<MutationName>>;
+    isExecuting: boolean;
+};
+/**
+ * TODO: Subscription management
+ */
+export declare const usePersistedSubscription: <SubscriptionName extends never>(subscriptionName: SubscriptionName) => never;
+type UseOnMutationFn<M> = () => void;
+/**
+ * Hook called when a mutation is issued, anywhere in the application.
+ * Useful for one-off situations where we want to subscribe and refetch something
+ * based on a mutation event
+ */
+export declare const useOnMutation: <M extends "*">(mutation: M | M[], fn: UseOnMutationFn<M>) => void;
+export {};