graphql-persisted 0.0.5 → 0.0.7

package/cjs/fragmentData.d.ts

@@ -1,4 +1,16 @@
 import './types';
+type Pretty<O> = {
+    [K in keyof O]: O[K];
+} & {};
+type UnwrapFragment<T> = T extends Array<infer U> ? Array<UnwrapFragment<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<ReadonlyArray<U>> : T extends object ? T extends {
+    ' $fragmentRefs'?: infer Refs;
+} ? Pretty<{
+    [K in keyof T as K extends ' $fragmentName' | ' $fragmentRefs' ? never : K]: UnwrapFragment<T[K]>;
+} & {
+    [K in keyof Refs]: UnwrapFragment<Refs[K]>;
+}[keyof Refs]> : {
+    [K in keyof T as K extends ' $fragmentName' ? never : K]: UnwrapFragment<T[K]>;
+} : T;
 export type FragmentType<Frag extends keyof GraphQLQuery.FragmentRegistry> = GraphQLQuery.FragmentRegistry[Frag] extends infer FragType ? FragType extends {
     ' $fragmentName'?: infer TKey;
 } ? TKey extends string ? {
@@ -6,8 +18,14 @@ export type FragmentType<Frag extends keyof GraphQLQuery.FragmentRegistry> = Gra
         [key in TKey]: FragType;
     };
 } : never : never : never;
+export type FragmentTypeUnwrapped<Frag extends keyof GraphQLQuery.FragmentRegistry> = GraphQLQuery.FragmentRegistry[Frag] extends infer FragType ? FragType extends object ? UnwrapFragment<FragType> : 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>;
+export declare function unwrapFragmentDeep<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: FragmentType<Frag>): FragmentTypeUnwrapped<Frag>;
+export declare function unwrapFragmentDeep<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: FragmentType<Frag> | null | undefined): FragmentTypeUnwrapped<Frag> | null | undefined;
+export declare function unwrapFragmentDeep<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: ReadonlyArray<FragmentType<Frag>>): ReadonlyArray<FragmentTypeUnwrapped<Frag>>;
+export declare function unwrapFragmentDeep<Frag extends keyof GraphQLQuery.FragmentRegistry>(_fragmentName: Frag, fragmentType: ReadonlyArray<FragmentType<Frag>> | null | undefined): ReadonlyArray<FragmentTypeUnwrapped<Frag>> | null | undefined;
+export declare function castFragmentData<F extends keyof GraphQLQuery.FragmentRegistry, FT extends FragmentTypeUnwrapped<F>>(_fragmentName: F, data: FT): FragmentType<F>;
+export {};

package/cjs/fragmentData.js

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

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/index.d.ts

@@ -1,6 +1,6 @@
 export { usePersistedQuery, usePersistedMutation, usePreloadedPersistedQuery, useOnMutation, usePersistedSubscription, } from './graphqlHooks.js';
-export { unwrapFragment, castFragmentData } from './fragmentData.js';
-export type { FragmentType } from './fragmentData.js';
+export { unwrapFragment, castFragmentData, unwrapFragmentDeep } from './fragmentData.js';
+export type { FragmentType, FragmentTypeUnwrapped } from './fragmentData.js';
 export { GraphQLQueryCache } from './GraphQLQueryCache.js';
 export { useGraphQLQueryCache, GraphQLQueryProvider } from './context.js';
 export type { GraphQLPreloadedQueryResult, GraphQLQueryResult, GraphQLQueryCacheConfig } from './types.js';

package/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphQLQueryProvider = exports.useGraphQLQueryCache = exports.GraphQLQueryCache = exports.castFragmentData = exports.unwrapFragment = exports.usePersistedSubscription = exports.useOnMutation = exports.usePreloadedPersistedQuery = exports.usePersistedMutation = exports.usePersistedQuery = void 0;
+exports.GraphQLQueryProvider = exports.useGraphQLQueryCache = exports.GraphQLQueryCache = exports.unwrapFragmentDeep = exports.castFragmentData = exports.unwrapFragment = exports.usePersistedSubscription = exports.useOnMutation = exports.usePreloadedPersistedQuery = exports.usePersistedMutation = exports.usePersistedQuery = void 0;
 var graphqlHooks_js_1 = require("./graphqlHooks.js");
 Object.defineProperty(exports, "usePersistedQuery", { enumerable: true, get: function () { return graphqlHooks_js_1.usePersistedQuery; } });
 Object.defineProperty(exports, "usePersistedMutation", { enumerable: true, get: function () { return graphqlHooks_js_1.usePersistedMutation; } });
@@ -10,6 +10,7 @@ Object.defineProperty(exports, "usePersistedSubscription", { enumerable: true, g
 var fragmentData_js_1 = require("./fragmentData.js");
 Object.defineProperty(exports, "unwrapFragment", { enumerable: true, get: function () { return fragmentData_js_1.unwrapFragment; } });
 Object.defineProperty(exports, "castFragmentData", { enumerable: true, get: function () { return fragmentData_js_1.castFragmentData; } });
+Object.defineProperty(exports, "unwrapFragmentDeep", { enumerable: true, get: function () { return fragmentData_js_1.unwrapFragmentDeep; } });
 var GraphQLQueryCache_js_1 = require("./GraphQLQueryCache.js");
 Object.defineProperty(exports, "GraphQLQueryCache", { enumerable: true, get: function () { return GraphQLQueryCache_js_1.GraphQLQueryCache; } });
 var context_js_1 = require("./context.js");

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;
 }