graphql-persisted 0.0.1 → 0.0.3

package/cjs/GraphQLQueryCache.js

@@ -1,22 +1,9 @@
 "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 tslib_1 = require("tslib");
+const lodash_isequal_1 = tslib_1.__importDefault(require("lodash.isequal"));
 const graphql_normalize_1 = require("graphql-normalize");
 const immer_1 = require("immer");
 const errors_1 = require("./errors");
@@ -70,14 +57,14 @@ class GraphQLQueryCache {
          * 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 ?? {
+        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_fetcher, config.fetcher || fetch, "f");
+        tslib_1.__classPrivateFieldSet(this, _GraphQLQueryCache_endpoint, config.endpoint || `${window.location.origin}/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 ?? {
             meta: {},
             fields: {},
             operations: {},
@@ -87,7 +74,7 @@ class GraphQLQueryCache {
      * Invalidates a query by name or predicate fn
      */
     invalidateQuery(toInvalidate) {
-        (0, immer_1.produce)(__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+        (0, immer_1.produce)(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
             //
         });
     }
@@ -95,7 +82,7 @@ class GraphQLQueryCache {
      * Invalidates a query by name or predicate fn
      */
     refetchQuery(toRefetch) {
-        (0, immer_1.produce)(__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
+        (0, immer_1.produce)(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_runtimeCache, "f"), () => {
             //
         });
     }
@@ -104,7 +91,7 @@ class GraphQLQueryCache {
      * to rehydrate the Client
      */
     toJSON() {
-        const { fields, operations, meta } = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
+        const { fields, operations, meta } = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
         return {
             fields,
             operations: operations,
@@ -142,19 +129,19 @@ 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 = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, queryName, variables);
+        const op = tslib_1.__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 meta = tslib_1.__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,
+            cache: tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").fields,
             isEqual: lodash_isequal_1.default,
         });
         return {
@@ -189,9 +176,9 @@ class GraphQLQueryCache {
     preloadQuery(queryName, options) {
         const { blockIfStale = true } = options;
         const variables = (0, helpers_1.variableString)(options.variables ?? {});
-        const sha256Hash = __classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[queryName];
+        const sha256Hash = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[queryName];
         const key = `${sha256Hash}:${variables}`;
-        const operation = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key];
+        const operation = tslib_1.__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: {} });
@@ -200,19 +187,19 @@ class GraphQLQueryCache {
         return operation;
     }
     fetchQuery(args) {
-        return __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_executeOperation).call(this, 'query', args.queryName, args.variables, args.options);
+        return tslib_1.__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);
+        return tslib_1.__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);
+        return tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_executeOperation).call(this, 'query', queryName, variables);
     }
     async executeSubscription() {
         throw new Error('Not yet supported');
@@ -225,8 +212,8 @@ 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 = 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] = []));
         queries.push(args);
         // Now that the component is subscribed, we can begin fetching,
         // refetching, and otherwise managing the query
@@ -244,18 +231,18 @@ class GraphQLQueryCache {
 }
 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];
+    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 = __classPrivateFieldGet(this, _GraphQLQueryCache_persistedOperations, "f")[operationName];
-    const key = __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_getKey).call(this, 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 = __classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key];
+    const inFlight = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key];
     if (operationType === 'query' && inFlight) {
         return inFlight;
     }
-    const operationInFlight = __classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_fetch).call(this, {
+    const operationInFlight = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_instances, "m", _GraphQLQueryCache_fetch).call(this, {
         query: '',
         operationName,
         variables: operationVariables,
@@ -263,21 +250,21 @@ _GraphQLQueryCache_fetcher = new WeakMap(), _GraphQLQueryCache_endpoint = new We
             persistedQuery: { version: 1, sha256Hash },
         },
     });
-    __classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key] = operationInFlight;
+    tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key] = operationInFlight;
     const operationResult = await operationInFlight.finally(() => {
-        delete __classPrivateFieldGet(this, _GraphQLQueryCache_inFlight, "f")[key];
+        delete tslib_1.__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);
+        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 = __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f");
-    __classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, (0, immer_1.produce)(__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f"), (c) => {
+    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',
@@ -329,14 +316,14 @@ _GraphQLQueryCache_fetcher = new WeakMap(), _GraphQLQueryCache_endpoint = new We
     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)) {
+        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 = __classPrivateFieldGet(this, _GraphQLQueryCache_queryInvalidation, "f")[queryName];
+            const queryFn = tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_queryInvalidation, "f")[queryName];
             if (queryFn?.(mutationName, operationVariables, queryVariables)) {
                 toInvalidate.add(operationKey);
             }
@@ -345,7 +332,7 @@ _GraphQLQueryCache_fetcher = new WeakMap(), _GraphQLQueryCache_endpoint = new We
             }
         }
         if (toInvalidate.size) {
-            __classPrivateFieldSet(this, _GraphQLQueryCache_cacheStore, (0, immer_1.produce)(__classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f"), (o) => {
+            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)
@@ -355,21 +342,21 @@ _GraphQLQueryCache_fetcher = new WeakMap(), _GraphQLQueryCache_endpoint = new We
         }
     }
     // 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 (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 (operationType === 'query') {
-        return __classPrivateFieldGet(this, _GraphQLQueryCache_cacheStore, "f").operations[key];
+        return tslib_1.__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];
+    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);
     }
@@ -382,7 +369,7 @@ _GraphQLQueryCache_fetcher = new WeakMap(), _GraphQLQueryCache_endpoint = new We
 async function _GraphQLQueryCache_fetch(body) {
     let result;
     try {
-        result = await fetch(__classPrivateFieldGet(this, _GraphQLQueryCache_endpoint, "f"), {
+        result = await fetch(tslib_1.__classPrivateFieldGet(this, _GraphQLQueryCache_endpoint, "f"), {
             method: 'POST',
             body: JSON.stringify(body),
             headers: {

package/cjs/fragmentData.d.ts

@@ -1,3 +1,4 @@
+import './types';
 export type FragmentType<Frag extends keyof GraphQLQuery.FragmentRegistry> = GraphQLQuery.FragmentRegistry[Frag] extends infer FragType ? FragType extends {
     ' $fragmentName'?: infer TKey;
 } ? TKey extends string ? {

package/cjs/fragmentData.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.castFragmentData = exports.unwrapFragment = void 0;
+require("./types");
 function unwrapFragment(_fragmentName, fragmentType) {
     return fragmentType;
 }

package/cjs/graphqlHooks.d.ts

@@ -6,7 +6,7 @@ import type { GraphQLPreloadedQueryResult, GraphQLQueryLazyResult, GraphQLQueryR
  * 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>;
+export declare function usePreloadedPersistedQuery<QueryName extends keyof GraphQLQuery.QueryRegistry>(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
@@ -18,31 +18,31 @@ export declare const usePreloadedPersistedQuery: <QueryName extends never>(query
  *    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>;
+export declare function usePersistedQuery<QueryName extends keyof GraphQLQuery.QueryRegistry>(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>;
+export declare function useLazyPersistedQuery<QueryName extends keyof GraphQLQuery.QueryRegistry>(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) => {
+export declare function usePersistedMutation<MutationName extends keyof GraphQLQuery.MutationRegistry>(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;
+export declare function usePersistedSubscription<SubscriptionName extends keyof GraphQLQuery.SubscriptionRegistry>(subscriptionName: SubscriptionName): void;
 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 declare function useOnMutation<M extends keyof GraphQLQuery.MutationRegistry | '*'>(mutation: M | Array<M>, fn: UseOnMutationFn<M>): void;
 export {};

package/cjs/graphqlHooks.js

@@ -12,8 +12,8 @@ const helpers_1 = require("./helpers");
  * 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.
  */
-const usePreloadedPersistedQuery = (query, options) => {
-    const result = (0, exports.usePersistedQuery)(query, options);
+function usePreloadedPersistedQuery(query, options) {
+    const result = usePersistedQuery(query, options);
     const lastData = (0, react_1.useRef)(result.data);
     const data = result.data ?? lastData.current;
     if (!data) {
@@ -25,7 +25,7 @@ const usePreloadedPersistedQuery = (query, options) => {
         }
     }, [result.data]);
     return { ...result, data };
-};
+}
 exports.usePreloadedPersistedQuery = usePreloadedPersistedQuery;
 /**
  * Retrieves the persisted query from the cache,
@@ -38,7 +38,7 @@ exports.usePreloadedPersistedQuery = usePreloadedPersistedQuery;
  *    a) The TTL setting
  *    b) A mutation which invalidates the query
  */
-const usePersistedQuery = (queryName, options) => {
+function usePersistedQuery(queryName, options) {
     const cache = (0, context_1.useGraphQLQueryCache)();
     const optionsRef = (0, react_1.useRef)(options);
     // Ensure we always have the latest options in the optionsRef
@@ -76,14 +76,14 @@ const usePersistedQuery = (queryName, options) => {
         ...queryResult,
         fetched: Boolean(queryResult),
     }; // GraphQLQuery.QueryRegistry[QueryName];
-};
+}
 exports.usePersistedQuery = usePersistedQuery;
 /**
  * TODO: Not working yet
  * Creates a container for a query that isn't fetched immediately,
  * but provides a loadQuery function to call
  */
-const useLazyPersistedQuery = (query) => {
+function useLazyPersistedQuery(query) {
     const data = (0, react_1.useRef)(undefined);
     const cache = (0, context_1.useGraphQLQueryCache)();
     // const state = useState<'pending' | 'fetched' | 'loading' | 'stale'>('pending')
@@ -104,14 +104,14 @@ const useLazyPersistedQuery = (query) => {
         stale,
         fetched,
     };
-};
+}
 exports.useLazyPersistedQuery = useLazyPersistedQuery;
 /**
  * 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
  */
-const usePersistedMutation = (mutationName, options) => {
+function usePersistedMutation(mutationName, options) {
     const cache = (0, context_1.useGraphQLQueryCache)();
     // Keeps track of whether we're executing the mutation or not, useful
     // for showing loading states when we know the mutation is in-flight
@@ -144,21 +144,21 @@ const usePersistedMutation = (mutationName, options) => {
         execute,
         isExecuting: Boolean(isExecuting > 0),
     };
-};
+}
 exports.usePersistedMutation = usePersistedMutation;
 /**
  * TODO: Subscription management
  */
-const usePersistedSubscription = (subscriptionName) => {
+function usePersistedSubscription(subscriptionName) {
     throw new Error(`usePersistedSubscription(${subscriptionName}) not yet supported`);
-};
+}
 exports.usePersistedSubscription = usePersistedSubscription;
 /**
  * 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
  */
-const useOnMutation = (mutation, fn) => {
+function useOnMutation(mutation, fn) {
     const fnRef = (0, react_1.useRef)(fn);
     const cache = (0, context_1.useGraphQLQueryCache)();
     (0, react_1.useEffect)(() => {
@@ -171,5 +171,5 @@ const useOnMutation = (mutation, fn) => {
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [cache, ...mutationDeps]);
-};
+}
 exports.useOnMutation = useOnMutation;

package/mjs/GraphQLQueryCache.js

@@ -1,15 +1,5 @@
-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 { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import isEqual from 'lodash.isequal';
 import { graphqlNormalize } from 'graphql-normalize';
 import { produce } from 'immer';

package/mjs/fragmentData.d.ts

@@ -1,3 +1,4 @@
+import './types';
 export type FragmentType<Frag extends keyof GraphQLQuery.FragmentRegistry> = GraphQLQuery.FragmentRegistry[Frag] extends infer FragType ? FragType extends {
     ' $fragmentName'?: infer TKey;
 } ? TKey extends string ? {

package/mjs/fragmentData.js

@@ -1,3 +1,4 @@
+import './types';
 export function unwrapFragment(_fragmentName, fragmentType) {
     return fragmentType;
 }

package/mjs/graphqlHooks.d.ts

@@ -6,7 +6,7 @@ import type { GraphQLPreloadedQueryResult, GraphQLQueryLazyResult, GraphQLQueryR
  * 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>;
+export declare function usePreloadedPersistedQuery<QueryName extends keyof GraphQLQuery.QueryRegistry>(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
@@ -18,31 +18,31 @@ export declare const usePreloadedPersistedQuery: <QueryName extends never>(query
  *    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>;
+export declare function usePersistedQuery<QueryName extends keyof GraphQLQuery.QueryRegistry>(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>;
+export declare function useLazyPersistedQuery<QueryName extends keyof GraphQLQuery.QueryRegistry>(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) => {
+export declare function usePersistedMutation<MutationName extends keyof GraphQLQuery.MutationRegistry>(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;
+export declare function usePersistedSubscription<SubscriptionName extends keyof GraphQLQuery.SubscriptionRegistry>(subscriptionName: SubscriptionName): void;
 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 declare function useOnMutation<M extends keyof GraphQLQuery.MutationRegistry | '*'>(mutation: M | Array<M>, fn: UseOnMutationFn<M>): void;
 export {};

package/mjs/graphqlHooks.js

@@ -9,7 +9,7 @@ import { serializeVariables } from './helpers';
  * 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 const usePreloadedPersistedQuery = (query, options) => {
+export function usePreloadedPersistedQuery(query, options) {
     const result = usePersistedQuery(query, options);
     const lastData = useRef(result.data);
     const data = result.data ?? lastData.current;
@@ -22,7 +22,7 @@ export const usePreloadedPersistedQuery = (query, options) => {
         }
     }, [result.data]);
     return { ...result, data };
-};
+}
 /**
  * Retrieves the persisted query from the cache,
  * creating it from the cache if we don't have a mounted version
@@ -34,7 +34,7 @@ export const usePreloadedPersistedQuery = (query, options) => {
  *    a) The TTL setting
  *    b) A mutation which invalidates the query
  */
-export const usePersistedQuery = (queryName, options) => {
+export function usePersistedQuery(queryName, options) {
     const cache = useGraphQLQueryCache();
     const optionsRef = useRef(options);
     // Ensure we always have the latest options in the optionsRef
@@ -72,13 +72,13 @@ export const usePersistedQuery = (queryName, options) => {
         ...queryResult,
         fetched: Boolean(queryResult),
     }; // GraphQLQuery.QueryRegistry[QueryName];
-};
+}
 /**
  * TODO: Not working yet
  * Creates a container for a query that isn't fetched immediately,
  * but provides a loadQuery function to call
  */
-export const useLazyPersistedQuery = (query) => {
+export function useLazyPersistedQuery(query) {
     const data = useRef(undefined);
     const cache = useGraphQLQueryCache();
     // const state = useState<'pending' | 'fetched' | 'loading' | 'stale'>('pending')
@@ -99,13 +99,13 @@ export const useLazyPersistedQuery = (query) => {
         stale,
         fetched,
     };
-};
+}
 /**
  * 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 const usePersistedMutation = (mutationName, options) => {
+export function usePersistedMutation(mutationName, options) {
     const cache = useGraphQLQueryCache();
     // Keeps track of whether we're executing the mutation or not, useful
     // for showing loading states when we know the mutation is in-flight
@@ -138,19 +138,19 @@ export const usePersistedMutation = (mutationName, options) => {
         execute,
         isExecuting: Boolean(isExecuting > 0),
     };
-};
+}
 /**
  * TODO: Subscription management
  */
-export const usePersistedSubscription = (subscriptionName) => {
+export function usePersistedSubscription(subscriptionName) {
     throw new Error(`usePersistedSubscription(${subscriptionName}) not yet supported`);
-};
+}
 /**
  * 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 const useOnMutation = (mutation, fn) => {
+export function useOnMutation(mutation, fn) {
     const fnRef = useRef(fn);
     const cache = useGraphQLQueryCache();
     useEffect(() => {
@@ -163,4 +163,4 @@ export const useOnMutation = (mutation, fn) => {
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [cache, ...mutationDeps]);
-};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-persisted",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "WIP: An Opinionated GraphQL Query Library, with a focus on fully persisted queries",
   "keywords": [
     "graphql",
@@ -28,6 +28,7 @@
     "cjs/*"
   ],
   "dependencies": {
+    "tslib": "^2.5.0",
     "graphql-normalize": "^0.2.1",
     "lodash.isequal": "^4.5.0"
   },
@@ -58,6 +59,7 @@
   },
   "scripts": {
     "clean": "rm -rf cjs && rm -rf mjs",
+    "predev": "pnpm install:example & pnpm install:example-server & pnpm install:example-codegen",
     "dev": "concurrently 'pnpm dev:example' 'pnpm dev:codegen' 'pnpm dev:example-server'",
     "dev:example": "cd example && pnpm dev",
     "dev:codegen": "cd example/codegen && pnpm dev",
@@ -66,7 +68,6 @@
     "build": "pnpm build:cjs && pnpm build:mjs",
     "build:cjs": "tsc -p tsconfig.build.json --noEmit false --outDir cjs",
     "build:mjs": "tsc -p tsconfig.build.json --noEmit false --outDir mjs --module ESNext --moduleResolution NodeNext",
-    "postinstall": "pnpm install:example & pnpm install:example-server & pnpm install:example-codegen",
     "install:example": "cd example && pnpm i",
     "install:example-server": "cd example/server && pnpm i",
     "install:example-codegen": "cd example/codegen && pnpm i",