···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

       
2
       
+
       
'@urql/core': patch

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Fix `fetchSource` not text-decoding response chunks as streams, which could cause UTF-8 decoding to break.

     

···

       
26
       
 
       
 * The implementation in this file needs to make certain accommodations for:

     

       
27
       
 
       
 * - The Web Fetch API

     

       
28
       
 
       
 * - Non-browser or polyfill Fetch APIs

     

       
29
       
-
       
 * - Node.js-like Fetch implementations (see `toString` below)

     

       
30
       
 
       
 *

     

       
31
       
 
       
 * GraphQL over SSE has a reference implementation, which supports non-HTTP/2

     

       
32
       
 
       
 * modes and is a faithful implementation of the spec.

     
···

       
47
       
 
       
import type { Operation, OperationResult, ExecutionResult } from '../types';

     

       
48
       
 
       
import { makeResult, makeErrorResult, mergeResultPatch } from '../utils';

     

       
49
       
 
       


     

       
50
       
-
       
const decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;

     

       
51
       
 
       
const boundaryHeaderRe = /boundary="?([^=";]+)"?/i;

     

       
52
       
 
       
const eventStreamRe = /data: ?([^\n]+)/;

     

       
53
       
 
       


     

       
54
       
 
       
type ChunkData = Buffer | Uint8Array;

     

       
55
       
 
       


     

       
56
       
-
       
// NOTE: We're avoiding referencing the `Buffer` global here to prevent

     

       
57
       
-
       
// auto-polyfilling in Webpack

     

       
58
       
-
       
const toString = (input: Buffer | ArrayBuffer): string =>

     

       
59
       
-
       
  input.constructor.name === 'Buffer'

     

       
60
       
-
       
    ? (input as Buffer).toString()

     

       
61
       
-
       
    : decoder!.decode(input as ArrayBuffer);

     

       
62
       
-
       


     

       
63
       
-
       
async function* streamBody(response: Response): AsyncIterableIterator<string> {

     

       
64
       
 
       
  if (response.body![Symbol.asyncIterator]) {

     

       
65
       
-
       
    for await (const chunk of response.body! as any)

     

       
66
       
-
       
      yield toString(chunk as ChunkData);

     

       
67
       
 
       
  } else {

     

       
68
       
 
       
    const reader = response.body!.getReader();

     

       
69
       
 
       
    let result: ReadableStreamReadResult<ChunkData>;

     

       
70
       
 
       
    try {

     

       
71
       
-
       
      while (!(result = await reader.read()).done) yield toString(result.value);

     

       
72
       
 
       
    } finally {

     

       
73
       
 
       
      reader.cancel();

     

       
74
       
 
       
    }

     

       
75
       
 
       
  }

     

       
76
       
 
       
}

     

       
77
       
 
       


     

       
78
       
-
       
async function* split(

     

       
79
       
-
       
  chunks: AsyncIterableIterator<string>,

     

       
80
       
 
       
  boundary: string

     

       
81
       
 
       
): AsyncIterableIterator<string> {

     

       
0
       
 
       

     

       
82
       
 
       
  let buffer = '';

     

       
83
       
 
       
  let boundaryIndex: number;

     

       
84
       
 
       
  for await (const chunk of chunks) {

     

       
85
       
-
       
    buffer += chunk;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
86
       
 
       
    while ((boundaryIndex = buffer.indexOf(boundary)) > -1) {

     

       
87
       
 
       
      yield buffer.slice(0, boundaryIndex);

     

       
88
       
 
       
      buffer = buffer.slice(boundaryIndex + boundary.length);

     
···

       
100
       
 
       
  response: Response

     

       
101
       
 
       
): AsyncIterableIterator<ExecutionResult> {

     

       
102
       
 
       
  let payload: any;

     

       
103
       
-
       
  for await (const chunk of split(streamBody(response), '\n\n')) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
104
       
 
       
    const match = chunk.match(eventStreamRe);

     

       
105
       
 
       
    if (match) {

     

       
106
       
 
       
      const chunk = match[1];

     
···

       
125
       
 
       
  const boundary = '--' + (boundaryHeader ? boundaryHeader[1] : '-');

     

       
126
       
 
       
  let isPreamble = true;

     

       
127
       
 
       
  let payload: any;

     

       
128
       
-
       
  for await (let chunk of split(streamBody(response), '\r\n' + boundary)) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
129
       
 
       
    if (isPreamble) {

     

       
130
       
 
       
      isPreamble = false;

     

       
131
       
 
       
      const preambleIndex = chunk.indexOf(boundary);

     

···

       
26
       
 
       
 * The implementation in this file needs to make certain accommodations for:

     

       
27
       
 
       
 * - The Web Fetch API

     

       
28
       
 
       
 * - Non-browser or polyfill Fetch APIs

     

       
29
       
+
       
 * - Node.js-like Fetch implementations

     

       
30
       
 
       
 *

     

       
31
       
 
       
 * GraphQL over SSE has a reference implementation, which supports non-HTTP/2

     

       
32
       
 
       
 * modes and is a faithful implementation of the spec.

     
···

       
47
       
 
       
import type { Operation, OperationResult, ExecutionResult } from '../types';

     

       
48
       
 
       
import { makeResult, makeErrorResult, mergeResultPatch } from '../utils';

     

       
49
       
 
       


     

       
0
       
 
       

     

       
50
       
 
       
const boundaryHeaderRe = /boundary="?([^=";]+)"?/i;

     

       
51
       
 
       
const eventStreamRe = /data: ?([^\n]+)/;

     

       
52
       
 
       


     

       
53
       
 
       
type ChunkData = Buffer | Uint8Array;

     

       
54
       
 
       


     

       
55
       
+
       
async function* streamBody(

     

       
56
       
+
       
  response: Response

     

       
57
       
+
       
): AsyncIterableIterator<ChunkData> {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
58
       
 
       
  if (response.body![Symbol.asyncIterator]) {

     

       
59
       
+
       
    for await (const chunk of response.body! as any) yield chunk as ChunkData;

     

       
0
       
 
       

     

       
60
       
 
       
  } else {

     

       
61
       
 
       
    const reader = response.body!.getReader();

     

       
62
       
 
       
    let result: ReadableStreamReadResult<ChunkData>;

     

       
63
       
 
       
    try {

     

       
64
       
+
       
      while (!(result = await reader.read()).done) yield result.value;

     

       
65
       
 
       
    } finally {

     

       
66
       
 
       
      reader.cancel();

     

       
67
       
 
       
    }

     

       
68
       
 
       
  }

     

       
69
       
 
       
}

     

       
70
       
 
       


     

       
71
       
+
       
async function* streamToBoundedChunks(

     

       
72
       
+
       
  chunks: AsyncIterableIterator<ChunkData>,

     

       
73
       
 
       
  boundary: string

     

       
74
       
 
       
): AsyncIterableIterator<string> {

     

       
75
       
+
       
  const decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;

     

       
76
       
 
       
  let buffer = '';

     

       
77
       
 
       
  let boundaryIndex: number;

     

       
78
       
 
       
  for await (const chunk of chunks) {

     

       
79
       
+
       
    // NOTE: We're avoiding referencing the `Buffer` global here to prevent

     

       
80
       
+
       
    // auto-polyfilling in Webpack

     

       
81
       
+
       
    buffer +=

     

       
82
       
+
       
      chunk.constructor.name === 'Buffer'

     

       
83
       
+
       
        ? (chunk as Buffer).toString()

     

       
84
       
+
       
        : decoder!.decode(chunk as ArrayBuffer, { stream: true });

     

       
85
       
 
       
    while ((boundaryIndex = buffer.indexOf(boundary)) > -1) {

     

       
86
       
 
       
      yield buffer.slice(0, boundaryIndex);

     

       
87
       
 
       
      buffer = buffer.slice(boundaryIndex + boundary.length);

     
···

       
99
       
 
       
  response: Response

     

       
100
       
 
       
): AsyncIterableIterator<ExecutionResult> {

     

       
101
       
 
       
  let payload: any;

     

       
102
       
+
       
  for await (const chunk of streamToBoundedChunks(

     

       
103
       
+
       
    streamBody(response),

     

       
104
       
+
       
    '\n\n'

     

       
105
       
+
       
  )) {

     

       
106
       
 
       
    const match = chunk.match(eventStreamRe);

     

       
107
       
 
       
    if (match) {

     

       
108
       
 
       
      const chunk = match[1];

     
···

       
127
       
 
       
  const boundary = '--' + (boundaryHeader ? boundaryHeader[1] : '-');

     

       
128
       
 
       
  let isPreamble = true;

     

       
129
       
 
       
  let payload: any;

     

       
130
       
+
       
  for await (let chunk of streamToBoundedChunks(

     

       
131
       
+
       
    streamBody(response),

     

       
132
       
+
       
    '\r\n' + boundary

     

       
133
       
+
       
  )) {

     

       
134
       
 
       
    if (isPreamble) {

     

       
135
       
 
       
      isPreamble = false;

     

       
136
       
 
       
      const preambleIndex = chunk.indexOf(boundary);