graphql-persisted 0.0.7 → 20.0.0

package/mjs/graphqlHooks.js

@@ -1,174 +0,0 @@
-import { useGraphQLQueryCache } from './context';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { ExpectedPreloadedQueryError } from './errors';
-import { serializeVariables } from './helpers';
-/**
- * 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 function usePreloadedPersistedQuery(query, options) {
-    const result = usePersistedQuery(query, options);
-    const lastData = useRef(result.data);
-    const data = result.data ?? lastData.current;
-    if (!data) {
-        throw new ExpectedPreloadedQueryError(query);
-    }
-    useEffect(() => {
-        if (result.data) {
-            lastData.current = result.data;
-        }
-    }, [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
- *
- * 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 function usePersistedQuery(queryName, options) {
-    const cache = useGraphQLQueryCache();
-    const optionsRef = useRef(options);
-    // Ensure we always have the latest options in the optionsRef
-    useEffect(() => {
-        optionsRef.current = options;
-    });
-    // We need the variables stringified anyway to persist in the cache
-    // simplest to just stringify them here
-    const variableString = useMemo(() => serializeVariables(options.variables ?? {}), [options.variables]);
-    // Read the query result from the cache
-    const readQueryResult = useMemo(() => {
-        return cache.tryReadQuery({
-            queryName,
-            variables: variableString,
-            options: optionsRef.current,
-        });
-    }, [queryName, variableString, cache]);
-    const [queryResult, setQueryResult] = useState(readQueryResult);
-    useEffect(() => {
-        setQueryResult(readQueryResult);
-    }, [readQueryResult]);
-    // If we don't have the query on mount, we fetch it.
-    // We "subscribe" to the query so we'll receive
-    // updates when the query values change, it becomes stale,
-    // or it is refetched
-    useEffect(() => {
-        return cache.subscribeToQuery({
-            queryResult,
-            queryName,
-            variables: variableString,
-            onUpdate: setQueryResult,
-            options: optionsRef.current,
-        });
-    }, [queryName, cache, queryResult, variableString]);
-    return {
-        ...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 function useLazyPersistedQuery(query) {
-    const data = useRef(undefined);
-    const cache = useGraphQLQueryCache();
-    // const state = useState<'pending' | 'fetched' | 'loading' | 'stale'>('pending')
-    const [stale, setIsStale] = useState(false);
-    const [fetched, setIsFetched] = useState(false);
-    const [loading, setIsLoading] = useState(false);
-    const loadQuery = useCallback((variables) => {
-        return new Promise((resolve, reject) => {
-            const result = cache.readOrFetchQuery({
-                queryName: query,
-                variables: serializeVariables(variables),
-                options: {},
-            });
-            // if ('then' in result && typeof result.then === 'function') {
-            //   Promise.resolve(result).then(resolve, reject)
-            // }
-        });
-    }, [cache, query]);
-    const errors = undefined;
-    return {
-        data: data.current,
-        errors,
-        loadQuery,
-        loading,
-        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 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
-    const [isExecuting, setIsExecuting] = useState(0);
-    const executingRef = useRef(new Map());
-    const optionsRef = useRef(options);
-    useEffect(() => {
-        optionsRef.current = options;
-    });
-    const execute = useCallback(async (vars, opts = {}) => {
-        const { skipDedupeGuard = false } = opts;
-        setIsExecuting((v) => v + 1);
-        const inFlightVars = serializeVariables(vars);
-        const executing = executingRef.current.get(inFlightVars);
-        if (executing && !skipDedupeGuard) {
-            return executing;
-        }
-        const inFlight = cache.executeMutation(mutationName, vars, optionsRef.current).finally(() => {
-            if (!skipDedupeGuard) {
-                executingRef.current.delete(inFlightVars);
-            }
-            setIsExecuting((v) => v - 1);
-        });
-        if (!skipDedupeGuard) {
-            executingRef.current.set(inFlightVars, inFlight);
-        }
-        return inFlight;
-    }, [cache, mutationName]);
-    return {
-        execute,
-        isExecuting: Boolean(isExecuting > 0),
-    };
-}
-/**
- * TODO: Subscription management
- */
-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 function useOnMutation(mutation, fn) {
-    const fnRef = useRef(fn);
-    const cache = useGraphQLQueryCache();
-    useEffect(() => {
-        fnRef.current = fn;
-    });
-    const mutationDeps = Array.isArray(mutation) ? mutation : [mutation];
-    useEffect(() => {
-        return () => {
-            //
-        };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [cache, ...mutationDeps]);
-}

package/mjs/helpers.d.ts

@@ -1,4 +0,0 @@
-import type { SerializedVariables } from './types';
-export declare function serializeVariables(vars: object): SerializedVariables;
-export declare function variableString(val: SerializedVariables | object): SerializedVariables;
-export declare function variableObject(val: SerializedVariables | object): any;

package/mjs/helpers.js

@@ -1,10 +0,0 @@
-import { stringifyVariables } from 'graphql-normalize';
-export function serializeVariables(vars) {
-    return stringifyVariables(vars);
-}
-export function variableString(val) {
-    return typeof val === 'string' ? val : serializeVariables(val);
-}
-export function variableObject(val) {
-    return typeof val === 'string' ? JSON.parse(val) : val;
-}

package/mjs/index.d.ts

@@ -1,8 +0,0 @@
-export { usePersistedQuery, usePersistedMutation, usePreloadedPersistedQuery, useOnMutation, usePersistedSubscription, } from './graphqlHooks.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';
-import type * as GraphQLQueryTypes from './types.js';
-export type { GraphQLQueryTypes };

package/mjs/index.js

@@ -1,4 +0,0 @@
-export { usePersistedQuery, usePersistedMutation, usePreloadedPersistedQuery, useOnMutation, usePersistedSubscription, } from './graphqlHooks.js';
-export { unwrapFragment, castFragmentData, unwrapFragmentDeep } from './fragmentData.js';
-export { GraphQLQueryCache } from './GraphQLQueryCache.js';
-export { useGraphQLQueryCache, GraphQLQueryProvider } from './context.js';

package/mjs/types.d.ts

@@ -1,205 +0,0 @@
-import type { NormalizeMetaShape } from 'graphql-normalize';
-import type { FormattedExecutionResult, GraphQLFormattedError } from 'graphql';
-import type { GraphQLQueryError } from './errors';
-declare global {
-    namespace GraphQLQuery {
-        interface QueryRegistry {
-        }
-        interface MutationRegistry {
-        }
-        interface SubscriptionRegistry {
-        }
-        interface OperationVariables {
-        }
-        interface FragmentRegistry {
-        }
-    }
-}
-export interface GraphQLOperationStoreShape<TData = unknown> {
-    operationType: 'query' | 'mutation' | 'subscription';
-    operationName: string;
-    meta: NormalizeMetaShape;
-    data?: TData | null;
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    extensions?: Record<string, unknown>;
-    variableValues: object;
-    lastFetchedAt?: Date;
-    stale: boolean;
-}
-export interface GraphQLCacheShape {
-    /**
-     * Normalized representation of the values for fields across all operations
-     */
-    fields: Record<string, unknown>;
-    /**
-     * Mapping of the operations we've seen
-     */
-    operations: Record<string, GraphQLOperationStoreShape<any>>;
-    /**
-     * "OperationName:meta" mapping
-     */
-    meta: Record<string, NormalizeMetaShape>;
-}
-export interface GraphQLHydratedCacheShape extends GraphQLCacheShape {
-    hydrated: Record<string, Record<string, string>>;
-}
-export interface GraphQLQueryCacheConfig {
-    /**
-     * The endpoint of our GraphQL Application
-     * @default /graphql
-     */
-    endpoint?: string;
-    /**
-     * Allows providing our own implementation of "fetch"
-     */
-    fetcher?: typeof fetch;
-    /**
-     * If we're Server-Side Rendering this code, we can serialize
-     * the GraphQLQueryCache and send down with the client bundle,
-     * so clients are able to re-hydrate and skip refetching
-     */
-    hydratedCache?: GraphQLCacheShape;
-    /**
-     * A mapping of graphql-normalize metadata, if we decide to provide
-     * it rather than sending it down alongside the query
-     *
-     * https://github.com/tgriesser/graphql-normalize
-     */
-    meta?: Record<string, any>;
-    /**
-     * Mapping of Query Name to hash of the query to execute
-     */
-    persistedOperations: Record<string, string>;
-    /**
-     * Reverse mapping of hashes to documents, useful in development situations
-     * where we might not have the hashes persisted on the server yet
-     */
-    persistedDocuments?: Record<string, string>;
-    /**
-     * Rather than having a mutation keep track of the queries it needs to invalidate,
-     * the invalidateOnMutation can specify that this query becomes "invalidated" when,
-     * a mutation, or specific mutation occurs, meaning the next time it's mounted,
-     * it'll be refetched
-     */
-    queryInvalidation?: Partial<{
-        [Q in keyof GraphQLQuery.QueryRegistry]: QueryInvalidationFn<Q>;
-    }>;
-    /**
-     * When the mutation executes and returns, allows us to invalidate queries,
-     * meaning they will be marked as "stale" and will be lazily refetched
-     * on subsequent renders.
-     */
-    mutationInvalidation?: Partial<{
-        [M in keyof GraphQLQuery.MutationRegistry]: MutationInvalidationFn<M>;
-    }>;
-    /**
-     * When an error happens in the query layer, it will run through this error handler.
-     */
-    globalOnError?: (e: GraphQLQueryError) => void;
-}
-export type QueryInvalidationFn<Q extends keyof GraphQLQuery.QueryRegistry = keyof GraphQLQuery.QueryRegistry> = <M extends keyof GraphQLQuery.MutationRegistry>(mutationName: M, mutationVariables: GraphQLQuery.OperationVariables[M], queryVariables: GraphQLQuery.OperationVariables[Q]) => boolean;
-export type MutationInvalidationFn<M extends keyof GraphQLQuery.MutationRegistry = keyof GraphQLQuery.MutationRegistry> = <Q extends keyof GraphQLQuery.QueryRegistry>(queryName: Q, queryVariables: GraphQLQuery.OperationVariables[Q], mutationVariables: GraphQLQuery.OperationVariables[M]) => boolean;
-export interface FetchError {
-    name: string;
-    message: string;
-    stack?: string;
-    status?: number;
-    statusText?: string;
-}
-export interface GraphQLOperationResult<Result> extends FormattedExecutionResult<Result> {
-    fetchError?: FetchError;
-}
-export type GraphQLMutationResult<MutationName extends keyof GraphQLQuery.MutationRegistry> = GraphQLOperationResult<GraphQLQuery.MutationRegistry[MutationName]>;
-export interface GraphQLQueryResult<QueryName extends keyof GraphQLQuery.QueryRegistry> extends GraphQLOperationResult<GraphQLQuery.QueryRegistry[QueryName]> {
-    fetched: boolean;
-}
-export interface GraphQLQueryLazyResult<QueryName extends keyof GraphQLQuery.QueryRegistry> extends GraphQLQueryResult<QueryName> {
-    stale: boolean;
-    loading: boolean;
-    loadQuery: (variables: GraphQLQuery.OperationVariables[QueryName]) => Promise<FormattedExecutionResult<GraphQLQuery.QueryRegistry[QueryName]>>;
-}
-export interface GraphQLPreloadedQueryResult<QueryName extends keyof GraphQLQuery.QueryRegistry> extends GraphQLQueryResult<QueryName> {
-    data: GraphQLQuery.QueryRegistry[QueryName];
-}
-export type MaybePromise<T> = T | Promise<T>;
-export interface GraphQLRequestBody {
-    query?: string;
-    variables: any;
-    operationName?: string;
-    extensions?: Record<string, any>;
-}
-export interface ExecutionOptions {
-    onError?: (e: GraphQLQueryError) => void;
-}
-export type QueryVariables<QueryName extends keyof GraphQLQuery.QueryRegistry> = QueryName extends keyof GraphQLQuery.OperationVariables ? GraphQLQuery.OperationVariables[QueryName] extends {
-    [key: string]: never;
-} ? {
-    variables?: unknown;
-} : {
-    variables: GraphQLQuery.OperationVariables[QueryName];
-} : never;
-export interface PersistedQueryOptions extends ExecutionOptions {
-    /**
-     * TTL in milliseconds for the query, after this we'll mark the query
-     * as "stale" and revalidate
-     */
-    ttl?: number;
-    /**
-     * Poll interval to refetch the query, in milliseconds.
-     */
-    pollInterval?: number;
-}
-export interface ReadQueryArgs<Q extends keyof GraphQLQuery.QueryRegistry> {
-    /**
-     *
-     */
-    queryName: Q;
-    /**
-     *
-     */
-    variables: SerializedVariables | GraphQLQuery.OperationVariables[Q];
-    /**
-     *
-     */
-    options: PersistedQueryOptions;
-}
-export interface SubscribeToQueryArgs<Q extends keyof GraphQLQuery.QueryRegistry> extends ReadQueryArgs<Q> {
-    /**
-     * The result of readQuery, used to check whether the query is stale
-     */
-    queryResult?: GraphQLOperationResult<Q>;
-    /**
-     * Invoked when the values for this query are updated
-     */
-    onUpdate: (nextVal: GraphQLOperationResult<Q>) => any;
-}
-export type InvalidateQueryArgs = keyof GraphQLQuery.QueryRegistry | Array<keyof GraphQLQuery.QueryRegistry>;
-export type SerializedVariables = string & {
-    __brand: 'SerializedVariables';
-};
-export type MutationTuple = {
-    [K in keyof GraphQLQuery.MutationRegistry]: [K, GraphQLQuery.OperationVariables[K]];
-}[keyof GraphQLQuery.MutationRegistry];
-export type SubscriptionTuple = {
-    [K in keyof GraphQLQuery.SubscriptionRegistry]: [K, GraphQLQuery.OperationVariables[K]];
-}[keyof GraphQLQuery.SubscriptionRegistry];
-export interface ExecuteMutationOptions {
-    /**
-     * By default, we check to ensure the mutation isn't already in-flight with the
-     * same variables
-     */
-    skipDedupeGuard?: boolean;
-}
-export type PreloadQueryOptions<Q extends keyof GraphQLQuery.QueryRegistry = keyof GraphQLQuery.QueryRegistry> = {
-    /**
-     * If we have the operation, but we know it's stale, we'll typically refetch
-     * and return the promise for the refetch. if "blockIfStale" is false, we will
-     * resolve immediately and refetch in the background
-     *
-     * @default true
-     */
-    blockIfStale?: boolean;
-} & QueryVariables<Q>;
-export type HasVariables<V extends keyof GraphQLQuery.OperationVariables> = {
-    [K in keyof GraphQLQuery.OperationVariables[V]]: GraphQLQuery.OperationVariables[V][K];
-}[keyof GraphQLQuery.OperationVariables[V]] extends never ? false : true;

package/mjs/types.js

@@ -1 +0,0 @@
-export {};