graphql-persisted 0.0.5 → 0.0.6

package/cjs/graphqlHooks.js

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

package/cjs/types.d.ts

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

package/mjs/GraphQLQueryCache.d.ts

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