graphql-persisted 0.0.7 → 20.0.0

package/mjs/GraphQLQueryCache.js

@@ -1,427 +0,0 @@
-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) {
-        // All queries we are "subscribed to", meaning that we React to any changes
-        // when there are updates to the cache.
-        this._subscribedQueries = {};
-        // All "in-flight" fetches, to deduplicate fetches that are already in-flight
-        // for an operation
-        this._inFlight = {};
-        // 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
-        this._runtimeCache = {};
-        /**
-         * A list of all "effects" that have run, used to keep track of
-         */
-        this._effectsIssued = []; // TODO: Include subscriptions
-        this._fetcher = config.fetcher;
-        this._endpoint = config.endpoint || `/graphql`;
-        this._persistedOperations = config.persistedOperations;
-        this._persistedDocuments = config.persistedDocuments;
-        this._configMeta = unwrapMeta(config.meta);
-        this._queryInvalidation = config.queryInvalidation ?? {};
-        this._mutationInvalidation = config.mutationInvalidation ?? {};
-        this._cacheStore = produce(config.hydratedCache ?? {
-            meta: {},
-            fields: {},
-            operations: {},
-        }, noop);
-    }
-    /**
-     * Invalidates a query by name or predicate fn
-     */
-    invalidateQuery(toInvalidate) {
-        produce(this._runtimeCache, () => {
-            //
-        });
-    }
-    /**
-     * Invalidates a query by name or predicate fn
-     */
-    refetchQuery(toRefetch) {
-        produce(this._runtimeCache, () => {
-            //
-        });
-    }
-    /**
-     * JSON.stringify(queryCache) produces the data we need
-     * to rehydrate the Client
-     */
-    toJSON() {
-        const { fields, operations, meta } = this._cacheStore;
-        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 = this._getKey(queryName, variables);
-        const op = this._cacheStore.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 = this._getMeta(queryName);
-        const { result } = graphqlNormalize({
-            action: 'read',
-            variableValues: typeof variables === 'string' ? JSON.parse(variables) : variables,
-            meta: meta,
-            cache: this._cacheStore.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 = this._persistedOperations[queryName];
-        const key = `${sha256Hash}:${variables}`;
-        const operation = this._cacheStore.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 this._executeOperation('query', args.queryName, args.variables, args.options);
-    }
-    /**
-     * Executes a mutation, returning the result of that mutation
-     */
-    async executeMutation(mutationName, variables, options = {}) {
-        return this._executeOperation('mutation', mutationName, variables, options);
-    }
-    /**
-     * Executes a query, returning the result of that query
-     */
-    async executeQuery(queryName, variables) {
-        return this._executeOperation('query', queryName, variables);
-    }
-    async executeSubscription() {
-        throw new Error('Not yet supported');
-    }
-    _getKey(operationName, variables) {
-        const sha256Hash = this._persistedOperations[operationName];
-        return `${sha256Hash}:${variableString(variables)}`;
-    }
-    /**
-     * "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 = this._getKey(queryName, variables);
-        const queries = ((_a = this._subscribedQueries)[key] ?? (_a[key] = []));
-        queries.push(args);
-        // Now that the component is subscribed, we can begin fetching,
-        // refetching, and otherwise managing the query
-        if (!queryResult) {
-            this.readOrFetchQuery(args);
-        }
-        else if (options.ttl) {
-            //
-        }
-        return () => {
-            queries.splice(queries.indexOf(args), 1);
-        };
-    }
-    async _executeOperation(operationType, operationName, variables) {
-        const sha256Hash = this._persistedOperations[operationName];
-        const key = this._getKey(operationName, variables);
-        const operationVariables = variableObject(variables);
-        assertOperationHash(sha256Hash, operationType, operationName);
-        const inFlight = this._inFlight[key];
-        if (operationType === 'query' && inFlight) {
-            return inFlight;
-        }
-        const operationInFlight = this._fetch({
-            query: '',
-            operationName,
-            variables: operationVariables,
-            extensions: {
-                persistedQuery: { version: 1, sha256Hash },
-            },
-        });
-        this._inFlight[key] = operationInFlight;
-        const operationResult = await operationInFlight.finally(() => {
-            delete this._inFlight[key];
-        });
-        if (operationResult.fetchError) {
-            return operationResult;
-        }
-        const meta = operationResult.extensions?.['graphqlNormalizeMeta'] ??
-            this._getMeta(operationName);
-        // Ensure we have metadata to be able to normalize the operation in our cache
-        if (!meta) {
-            throw new MissingMetaError(operationName);
-        }
-        const lastCache = this._cacheStore;
-        this._cacheStore = produce(this._cacheStore, (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;
-                        }
-                    }
-                }
-            }
-        });
-        // 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 = this._mutationInvalidation?.[mutationName];
-            for (const [operationKey, operation] of Object.entries(this._cacheStore.operations)) {
-                if (operation.operationType !== 'query') {
-                    continue;
-                }
-                const queryName = operation.operationName;
-                const queryVariables = operation.variableValues;
-                const queryFn = this._queryInvalidation[queryName];
-                if (queryFn?.(mutationName, operationVariables, queryVariables)) {
-                    toInvalidate.add(operationKey);
-                }
-                if (mutationFn?.(queryName, queryVariables, operationVariables)) {
-                    toInvalidate.add(operationKey);
-                }
-            }
-            if (toInvalidate.size) {
-                this._cacheStore = produce(this._cacheStore, (o) => {
-                    for (const key of toInvalidate) {
-                        const op = o.operations[key];
-                        if (op)
-                            op.stale = true;
-                    }
-                });
-            }
-        }
-        // If we've updated any operations, we need to update any subscribed components
-        if (lastCache.operations !== this._cacheStore.operations) {
-            for (const [key, val] of Object.entries(this._cacheStore.operations)) {
-                if (this._cacheStore.operations[key] !== lastCache.operations[key]) {
-                    if (this._subscribedQueries[key]) {
-                        this._subscribedQueries[key]?.forEach((o) => o.onUpdate(val));
-                    }
-                }
-            }
-        }
-        if (operationType === 'query') {
-            return this._cacheStore.operations[key];
-        }
-        return operationResult;
-    }
-    _getMeta(opName) {
-        const meta = this._cacheStore.meta[opName] ?? this._configMeta?.[opName];
-        if (!meta) {
-            throw new MissingMetaError(opName);
-        }
-        return meta;
-    }
-    /**
-     * 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 _fetch(body) {
-        let result;
-        try {
-            result = await this._makeFetch(body);
-            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,
-                },
-            };
-        }
-    }
-    _makeFetch(body) {
-        const reqInit = {
-            method: 'POST',
-            body: JSON.stringify(body),
-            headers: {
-                'content-type': 'application/json',
-            },
-        };
-        if (this._fetcher) {
-            return this._fetcher(this._endpoint, reqInit);
-        }
-        return fetch(this._endpoint, reqInit);
-    }
-    /**
-     * Determine whether we should refetch the query based on the
-     * current value of the query, and the options passed to the query
-     */
-    _shouldRefetchQuery() {
-        //
-    }
-    /**
-     * "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() {
-        //
-    }
-}
-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

@@ -1,21 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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 ? {
-    ' $fragmentRefs'?: {
-        [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 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/mjs/fragmentData.js

@@ -1,10 +0,0 @@
-import './types';
-export function unwrapFragment(_fragmentName, fragmentType) {
-    return fragmentType;
-}
-export function unwrapFragmentDeep(_fragmentName, fragmentType) {
-    return fragmentType;
-}
-export function castFragmentData(_fragmentName, data) {
-    return data;
-}

package/mjs/graphqlHooks.d.ts

@@ -1,48 +0,0 @@
-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 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
- *
- * 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 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 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 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 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 function useOnMutation<M extends keyof GraphQLQuery.MutationRegistry | '*'>(mutation: M | Array<M>, fn: UseOnMutationFn<M>): void;
-export {};