···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

       
2
       
+
       
'@urql/exchange-persisted-fetch': patch

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Fix `persistedFetchExchange` not sending the SHA256 hash extension after a cache miss (`PersistedQueryNotFound` error)

     

···

       
4
       
 
       


     

       
5
       
 
       
exports[`supports cache-miss persisted query errors 1`] = `"{\\"operationName\\":\\"getUser\\",\\"variables\\":{\\"name\\":\\"Clara\\"},\\"extensions\\":{\\"persistedQuery\\":{\\"version\\":1,\\"sha256Hash\\":\\"bfa84414672fe625d36f2d2a52e1d3c1e71c5a01e79599c320db7656d6f014d4\\"}}}"`;

     

       
6
       
 
       


     

       
7
       
-
       
exports[`supports cache-miss persisted query errors 2`] = `"{\\"query\\":\\"query getUser($name: String) {\\\\n  user(name: $name) {\\\\n    id\\\\n    firstName\\\\n    lastName\\\\n  }\\\\n}\\\\n\\",\\"operationName\\":\\"getUser\\",\\"variables\\":{\\"name\\":\\"Clara\\"}}"`;

     

       
8
       
 
       


     

       
9
       
 
       
exports[`supports unsupported persisted query errors 1`] = `"{\\"operationName\\":\\"getUser\\",\\"variables\\":{\\"name\\":\\"Clara\\"},\\"extensions\\":{\\"persistedQuery\\":{\\"version\\":1,\\"sha256Hash\\":\\"bfa84414672fe625d36f2d2a52e1d3c1e71c5a01e79599c320db7656d6f014d4\\"}}}"`;

     

···

       
4
       
 
       


     

       
5
       
 
       
exports[`supports cache-miss persisted query errors 1`] = `"{\\"operationName\\":\\"getUser\\",\\"variables\\":{\\"name\\":\\"Clara\\"},\\"extensions\\":{\\"persistedQuery\\":{\\"version\\":1,\\"sha256Hash\\":\\"bfa84414672fe625d36f2d2a52e1d3c1e71c5a01e79599c320db7656d6f014d4\\"}}}"`;

     

       
6
       
 
       


     

       
7
       
+
       
exports[`supports cache-miss persisted query errors 2`] = `"{\\"query\\":\\"query getUser($name: String) {\\\\n  user(name: $name) {\\\\n    id\\\\n    firstName\\\\n    lastName\\\\n  }\\\\n}\\\\n\\",\\"operationName\\":\\"getUser\\",\\"variables\\":{\\"name\\":\\"Clara\\"},\\"extensions\\":{\\"persistedQuery\\":{\\"version\\":1,\\"sha256Hash\\":\\"bfa84414672fe625d36f2d2a52e1d3c1e71c5a01e79599c320db7656d6f014d4\\"}}}"`;

     

       
8
       
 
       


     

       
9
       
 
       
exports[`supports unsupported persisted query errors 1`] = `"{\\"operationName\\":\\"getUser\\",\\"variables\\":{\\"name\\":\\"Clara\\"},\\"extensions\\":{\\"persistedQuery\\":{\\"version\\":1,\\"sha256Hash\\":\\"bfa84414672fe625d36f2d2a52e1d3c1e71c5a01e79599c320db7656d6f014d4\\"}}}"`;

     

···

       
21
       
 
       
} from '@urql/core';

     

       
22
       
 
       


     

       
23
       
 
       
import {

     

       
0
       
 
       

     

       
24
       
 
       
  makeFetchBody,

     

       
25
       
 
       
  makeFetchURL,

     

       
26
       
 
       
  makeFetchOptions,

     
···

       
47
       
 
       
          filter(op => op.operationName === 'teardown' && op.key === key)

     

       
48
       
 
       
        );

     

       
49
       
 
       


     

       
0
       
 
       

     

       
50
       
 
       
        if (!supportsPersistedQueries) {

     

       
0
       
 
       

     

       
51
       
 
       
          return pipe(

     

       
52
       
-
       
            makeNormalFetchSource(operation, dispatchDebug),

     

       
53
       
 
       
            takeUntil(teardown$)

     

       
54
       
 
       
          );

     

       
55
       
 
       
        }

     

       
56
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
57
       
 
       
        return pipe(

     

       
58
       
-
       
          makePersistedFetchSource(operation, dispatchDebug),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
59
       
 
       
          mergeMap(result => {

     

       
60
       
 
       
            if (result.error && isPersistedUnsupported(result.error)) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
61
       
 
       
              supportsPersistedQueries = false;

     

       
62
       
-
       
              return makeNormalFetchSource(operation, dispatchDebug);

     

       
63
       
 
       
            } else if (result.error && isPersistedMiss(result.error)) {

     

       
64
       
-
       
              return makeNormalFetchSource(operation, dispatchDebug);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
65
       
 
       
            }

     

       
66
       
 
       


     

       
67
       
 
       
            return fromValue(result);

     
···

       
83
       
 
       


     

       
84
       
 
       
const makePersistedFetchSource = (

     

       
85
       
 
       
  operation: Operation,

     

       
0
       
 
       

     

       
86
       
 
       
  dispatchDebug: ExchangeInput['dispatchDebug']

     

       
87
       
 
       
): Source<OperationResult> => {

     

       
88
       
-
       
  const body = makeFetchBody(operation);

     

       
89
       
-
       
  const query: string = body.query!;

     

       
90
       
-
       


     

       
91
       
-
       
  return pipe(

     

       
92
       
-
       
    fromPromise(hash(query)),

     

       
93
       
-
       
    mergeMap(sha256Hash => {

     

       
94
       
-
       
      body.query = undefined;

     

       
95
       
-
       
      body.extensions = {

     

       
96
       
-
       
        persistedQuery: {

     

       
97
       
-
       
          version: 1,

     

       
98
       
-
       
          sha256Hash,

     

       
99
       
-
       
        },

     

       
100
       
-
       
      };

     

       
101
       
-
       


     

       
102
       
-
       
      const url = makeFetchURL(operation, { ...body, query: '' });

     

       
103
       
-
       
      const fetchOptions = makeFetchOptions(operation, body);

     

       
104
       
-
       


     

       
105
       
-
       
      dispatchDebug({

     

       
106
       
-
       
        type: 'fetchRequest',

     

       
107
       
-
       
        message: 'A fetch request for a persisted query is being executed.',

     

       
108
       
-
       
        operation,

     

       
109
       
-
       
        data: {

     

       
110
       
-
       
          url,

     

       
111
       
-
       
          fetchOptions,

     

       
112
       
-
       
        },

     

       
113
       
-
       
      });

     

       
114
       
-
       


     

       
115
       
-
       
      return pipe(

     

       
116
       
-
       
        makeFetchSource(operation, url, fetchOptions),

     

       
117
       
-
       
        onPush(result => {

     

       
118
       
-
       
          const persistFail =

     

       
119
       
-
       
            result.error &&

     

       
120
       
-
       
            (isPersistedMiss(result.error) ||

     

       
121
       
-
       
              isPersistedUnsupported(result.error));

     

       
122
       
-
       
          const error = !result.data ? result.error : undefined;

     

       
123
       
-
       


     

       
124
       
-
       
          dispatchDebug({

     

       
125
       
-
       
            // TODO: Assign a new name to this once @urql/devtools supports it

     

       
126
       
-
       
            type: persistFail || error ? 'fetchError' : 'fetchSuccess',

     

       
127
       
-
       
            message: persistFail

     

       
128
       
-
       
              ? 'A Persisted Query request has failed. A non-persisted GraphQL request will follow.'

     

       
129
       
-
       
              : `A ${

     

       
130
       
-
       
                  error ? 'failed' : 'successful'

     

       
131
       
-
       
                } fetch response has been returned.`,

     

       
132
       
-
       
            operation,

     

       
133
       
-
       
            data: {

     

       
134
       
-
       
              url,

     

       
135
       
-
       
              fetchOptions,

     

       
136
       
-
       
              value: persistFail ? result.error! : error || result,

     

       
137
       
-
       
            },

     

       
138
       
-
       
          });

     

       
139
       
-
       
        })

     

       
140
       
-
       
      );

     

       
141
       
-
       
    })

     

       
142
       
 
       
  );

     

       
143
       
-
       
};

     

       
144
       
-
       


     

       
145
       
-
       
const makeNormalFetchSource = (

     

       
146
       
-
       
  operation: Operation,

     

       
147
       
-
       
  dispatchDebug: ExchangeInput['dispatchDebug']

     

       
148
       
-
       
): Source<OperationResult> => {

     

       
149
       
-
       
  const body = makeFetchBody(operation);

     

       
150
       
-
       
  const url = makeFetchURL(operation, body);

     

       
151
       
 
       
  const fetchOptions = makeFetchOptions(operation, body);

     

       
152
       
 
       


     

       
153
       
 
       
  dispatchDebug({

     

       
154
       
 
       
    type: 'fetchRequest',

     

       
155
       
-
       
    message: 'A fetch request is being executed.',

     

       
0
       
 
       

     

       
0
       
 
       

     

       
156
       
 
       
    operation,

     

       
157
       
 
       
    data: {

     

       
158
       
 
       
      url,

     
···

       
163
       
 
       
  return pipe(

     

       
164
       
 
       
    makeFetchSource(operation, url, fetchOptions),

     

       
165
       
 
       
    onPush(result => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
166
       
 
       
      const error = !result.data ? result.error : undefined;

     

       
167
       
 
       


     

       
168
       
 
       
      dispatchDebug({

     

       
169
       
-
       
        type: error ? 'fetchError' : 'fetchSuccess',

     

       
170
       
-
       
        message: `A ${

     

       
171
       
-
       
          error ? 'failed' : 'successful'

     

       
172
       
-
       
        } fetch response has been returned.`,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
173
       
 
       
        operation,

     

       
174
       
 
       
        data: {

     

       
175
       
 
       
          url,

     

       
176
       
 
       
          fetchOptions,

     

       
177
       
-
       
          value: error || result,

     

       
178
       
 
       
        },

     

       
179
       
 
       
      });

     

       
180
       
 
       
    })

     

···

       
21
       
 
       
} from '@urql/core';

     

       
22
       
 
       


     

       
23
       
 
       
import {

     

       
24
       
+
       
  FetchBody,

     

       
25
       
 
       
  makeFetchBody,

     

       
26
       
 
       
  makeFetchURL,

     

       
27
       
 
       
  makeFetchOptions,

     
···

       
48
       
 
       
          filter(op => op.operationName === 'teardown' && op.key === key)

     

       
49
       
 
       
        );

     

       
50
       
 
       


     

       
51
       
+
       
        const body = makeFetchBody(operation);

     

       
52
       
 
       
        if (!supportsPersistedQueries) {

     

       
53
       
+
       
          // Runs the usual non-persisted fetchExchange query logic

     

       
54
       
 
       
          return pipe(

     

       
55
       
+
       
            makePersistedFetchSource(operation, body, dispatchDebug),

     

       
56
       
 
       
            takeUntil(teardown$)

     

       
57
       
 
       
          );

     

       
58
       
 
       
        }

     

       
59
       
 
       


     

       
60
       
+
       
        const query: string = body.query!;

     

       
61
       
+
       


     

       
62
       
 
       
        return pipe(

     

       
63
       
+
       
          // Hash the given GraphQL query

     

       
64
       
+
       
          fromPromise(hash(query)),

     

       
65
       
+
       
          mergeMap(sha256Hash => {

     

       
66
       
+
       
            // Attach SHA256 hash and remove query from body

     

       
67
       
+
       
            body.query = undefined;

     

       
68
       
+
       
            body.extensions = {

     

       
69
       
+
       
              persistedQuery: {

     

       
70
       
+
       
                version: 1,

     

       
71
       
+
       
                sha256Hash,

     

       
72
       
+
       
              },

     

       
73
       
+
       
            };

     

       
74
       
+
       


     

       
75
       
+
       
            return makePersistedFetchSource(operation, body, dispatchDebug);

     

       
76
       
+
       
          }),

     

       
77
       
 
       
          mergeMap(result => {

     

       
78
       
 
       
            if (result.error && isPersistedUnsupported(result.error)) {

     

       
79
       
+
       
              // Reset the body back to its non-persisted state

     

       
80
       
+
       
              body.query = query;

     

       
81
       
+
       
              body.extensions = undefined;

     

       
82
       
+
       
              // Disable future persisted queries

     

       
83
       
 
       
              supportsPersistedQueries = false;

     

       
84
       
+
       
              return makePersistedFetchSource(operation, body, dispatchDebug);

     

       
85
       
 
       
            } else if (result.error && isPersistedMiss(result.error)) {

     

       
86
       
+
       
              // Add query to the body but leave SHA256 hash intact

     

       
87
       
+
       
              body.query = query;

     

       
88
       
+
       
              return makePersistedFetchSource(operation, body, dispatchDebug);

     

       
89
       
 
       
            }

     

       
90
       
 
       


     

       
91
       
 
       
            return fromValue(result);

     
···

       
107
       
 
       


     

       
108
       
 
       
const makePersistedFetchSource = (

     

       
109
       
 
       
  operation: Operation,

     

       
110
       
+
       
  body: FetchBody,

     

       
111
       
 
       
  dispatchDebug: ExchangeInput['dispatchDebug']

     

       
112
       
 
       
): Source<OperationResult> => {

     

       
113
       
+
       
  const url = makeFetchURL(

     

       
114
       
+
       
    operation,

     

       
115
       
+
       
    body.query ? body : { ...body, query: '' }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
116
       
 
       
  );

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
117
       
 
       
  const fetchOptions = makeFetchOptions(operation, body);

     

       
118
       
 
       


     

       
119
       
 
       
  dispatchDebug({

     

       
120
       
 
       
    type: 'fetchRequest',

     

       
121
       
+
       
    message: !body.query

     

       
122
       
+
       
      ? 'A fetch request for a persisted query is being executed.'

     

       
123
       
+
       
      : 'A fetch request is being executed.',

     

       
124
       
 
       
    operation,

     

       
125
       
 
       
    data: {

     

       
126
       
 
       
      url,

     
···

       
131
       
 
       
  return pipe(

     

       
132
       
 
       
    makeFetchSource(operation, url, fetchOptions),

     

       
133
       
 
       
    onPush(result => {

     

       
134
       
+
       
      const persistFail =

     

       
135
       
+
       
        result.error &&

     

       
136
       
+
       
        (isPersistedMiss(result.error) || isPersistedUnsupported(result.error));

     

       
137
       
 
       
      const error = !result.data ? result.error : undefined;

     

       
138
       
 
       


     

       
139
       
 
       
      dispatchDebug({

     

       
140
       
+
       
        // TODO: Assign a new name to this once @urql/devtools supports it

     

       
141
       
+
       
        type: persistFail || error ? 'fetchError' : 'fetchSuccess',

     

       
142
       
+
       
        message: persistFail

     

       
143
       
+
       
          ? 'A Persisted Query request has failed. A non-persisted GraphQL request will follow.'

     

       
144
       
+
       
          : `A ${

     

       
145
       
+
       
              error ? 'failed' : 'successful'

     

       
146
       
+
       
            } fetch response has been returned.`,

     

       
147
       
 
       
        operation,

     

       
148
       
 
       
        data: {

     

       
149
       
 
       
          url,

     

       
150
       
 
       
          fetchOptions,

     

       
151
       
+
       
          value: persistFail ? result.error! : error || result,

     

       
152
       
 
       
        },

     

       
153
       
 
       
      });

     

       
154
       
 
       
    })