@graphql-tools/url-loader 7.10.0 → 7.11.0-alpha-6c480b2d.0

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_WS = exports.isPromiseLike = exports.isGraphQLUpload = exports.isBlob = void 0;
+function isBlob(obj) {
+    return typeof obj.arrayBuffer === 'function';
+}
+exports.isBlob = isBlob;
+function isGraphQLUpload(upload) {
+    return typeof upload.createReadStream === 'function';
+}
+exports.isGraphQLUpload = isGraphQLUpload;
+function isPromiseLike(obj) {
+    return typeof obj.then === 'function';
+}
+exports.isPromiseLike = isPromiseLike;
+var LEGACY_WS;
+(function (LEGACY_WS) {
+    LEGACY_WS["CONNECTION_INIT"] = "connection_init";
+    LEGACY_WS["CONNECTION_ACK"] = "connection_ack";
+    LEGACY_WS["CONNECTION_ERROR"] = "connection_error";
+    LEGACY_WS["CONNECTION_KEEP_ALIVE"] = "ka";
+    LEGACY_WS["START"] = "start";
+    LEGACY_WS["STOP"] = "stop";
+    LEGACY_WS["CONNECTION_TERMINATE"] = "connection_terminate";
+    LEGACY_WS["DATA"] = "data";
+    LEGACY_WS["ERROR"] = "error";
+    LEGACY_WS["COMPLETE"] = "complete";
+})(LEGACY_WS = exports.LEGACY_WS || (exports.LEGACY_WS = {}));

package/esm/addCancelToResponseStream.js

@@ -0,0 +1,8 @@
+import { withCancel } from '@graphql-tools/utils';
+export function addCancelToResponseStream(resultStream, controller) {
+    return withCancel(resultStream, () => {
+        if (!controller.signal.aborted) {
+            controller.abort();
+        }
+    });
+}

package/esm/defaultAsyncFetch.js

@@ -0,0 +1,4 @@
+import { fetch } from 'cross-undici-fetch';
+export const defaultAsyncFetch = async (input, init) => {
+    return fetch(input, init);
+};

package/esm/defaultSyncFetch.js

@@ -0,0 +1,10 @@
+import syncFetchImported from 'sync-fetch';
+export const defaultSyncFetch = (input, init) => {
+    if (typeof input === 'string') {
+        init === null || init === void 0 ? true : delete init.signal;
+    }
+    else {
+        delete input.signal;
+    }
+    return syncFetchImported(input, init);
+};

package/esm/event-stream/handleEventStreamResponse.js

@@ -0,0 +1,14 @@
+import { inspect, isAsyncIterable } from '@graphql-tools/utils';
+import { handleReadable } from './handleReadable.js';
+import { handleReadableStream } from './handleReadableStream.js';
+export async function handleEventStreamResponse(response) {
+    // node-fetch returns body as a promise so we need to resolve it
+    const body = await response.body;
+    if (body) {
+        if (isAsyncIterable(body)) {
+            return handleReadable(body);
+        }
+        return handleReadableStream(body);
+    }
+    throw new Error('Response body is expected to be a readable stream but got; ' + inspect(body));
+}

package/esm/event-stream/handleReadable.js

@@ -0,0 +1,27 @@
+/* eslint-disable no-labels */
+let decodeUint8Array;
+if (globalThis.Buffer) {
+    decodeUint8Array = uint8Array => globalThis.Buffer.from(uint8Array).toString('utf-8');
+}
+else {
+    const textDecoder = new TextDecoder();
+    decodeUint8Array = uint8Array => textDecoder.decode(uint8Array);
+}
+export async function* handleReadable(readable) {
+    outer: for await (const chunk of readable) {
+        const chunkStr = typeof chunk === 'string' ? chunk : decodeUint8Array(chunk);
+        for (const part of chunkStr.split('\n\n')) {
+            if (part) {
+                const eventStr = part.split('event: ')[1];
+                const dataStr = part.split('data: ')[1];
+                if (eventStr === 'complete') {
+                    break outer;
+                }
+                if (dataStr) {
+                    const data = JSON.parse(dataStr);
+                    yield data.payload || data;
+                }
+            }
+        }
+    }
+}

package/esm/event-stream/handleReadableStream.js

@@ -0,0 +1,127 @@
+// Based on https://github.com/Azure/fetch-event-source/blob/main/src/parse.ts
+export async function* handleReadableStream(stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let buffer;
+    let position = 0; // current read position
+    let fieldLength = -1; // length of the `field` portion of the line
+    let discardTrailingNewline = false;
+    try {
+        let result;
+        let message = {
+            data: '',
+            event: '',
+            id: '',
+            retry: undefined,
+        };
+        while (!(result = await reader.read()).done) {
+            const arr = result.value;
+            if (buffer === undefined) {
+                buffer = arr;
+                position = 0;
+                fieldLength = -1;
+            }
+            else {
+                // we're still parsing the old line. Append the new bytes into buffer:
+                buffer = concat(buffer, arr);
+            }
+            const bufLength = buffer.length;
+            let lineStart = 0; // index where the current line starts
+            while (position < bufLength) {
+                if (discardTrailingNewline) {
+                    if (buffer[position] === 10 /* ControlChars.NewLine */) {
+                        lineStart = ++position; // skip to next char
+                    }
+                    discardTrailingNewline = false;
+                }
+                // start looking forward till the end of line:
+                let lineEnd = -1; // index of the \r or \n char
+                for (; position < bufLength && lineEnd === -1; ++position) {
+                    switch (buffer[position]) {
+                        case 58 /* ControlChars.Colon */: {
+                            if (fieldLength === -1) {
+                                // first colon in line
+                                fieldLength = position - lineStart;
+                            }
+                            break;
+                        }
+                        case 13 /* ControlChars.CarriageReturn */: {
+                            discardTrailingNewline = true;
+                            break;
+                        }
+                        case 10 /* ControlChars.NewLine */: {
+                            lineEnd = position;
+                            break;
+                        }
+                    }
+                }
+                if (lineEnd === -1) {
+                    // We reached the end of the buffer but the line hasn't ended.
+                    // Wait for the next arr and then continue parsing:
+                    break;
+                }
+                // we've reached the line end, send it out:
+                const line = buffer.subarray(lineStart, lineEnd);
+                if (line.length === 0) {
+                    // empty line denotes end of message. Trigger the callback and start a new message:
+                    if (message.event || message.data) {
+                        // NOT a server ping (":\n\n")
+                        yield JSON.parse(message.data);
+                        message = {
+                            data: '',
+                            event: '',
+                            id: '',
+                            retry: undefined,
+                        };
+                    }
+                }
+                else if (fieldLength > 0) {
+                    // exclude comments and lines with no values
+                    // line is of format "<field>:<value>" or "<field>: <value>"
+                    // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+                    const field = decoder.decode(line.subarray(0, fieldLength));
+                    const valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* ControlChars.Space */ ? 2 : 1);
+                    const value = decoder.decode(line.subarray(valueOffset));
+                    switch (field) {
+                        case 'data':
+                            // if this message already has data, append the new value to the old.
+                            // otherwise, just set to the new value:
+                            message.data = message.data ? message.data + '\n' + value : value; // otherwise,
+                            break;
+                        case 'event':
+                            message.event = value;
+                            break;
+                        case 'id':
+                            message.id = value;
+                            break;
+                        case 'retry': {
+                            const retry = parseInt(value, 10);
+                            message.retry = retry;
+                            break;
+                        }
+                    }
+                }
+                lineStart = position; // we're now on the next line
+                fieldLength = -1;
+            }
+            if (lineStart === bufLength) {
+                buffer = undefined; // we've finished reading it
+            }
+            else if (lineStart !== 0) {
+                // Create a new view into buffer beginning at lineStart so we don't
+                // need to copy over the previous lines when we get the new arr:
+                buffer = buffer.subarray(lineStart);
+                position -= lineStart;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function concat(a, b) {
+    const res = new Uint8Array(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+}

package/esm/handleMultipartMixedResponse.js

@@ -0,0 +1,48 @@
+import { meros as merosIncomingMessage } from 'meros/node';
+import { meros as merosReadableStream } from 'meros/browser';
+import { mapAsyncIterator } from '@graphql-tools/utils';
+import { dset } from 'dset/merge';
+function isIncomingMessage(body) {
+    return body != null && typeof body === 'object' && 'pipe' in body;
+}
+export async function handleMultipartMixedResponse(response) {
+    const body = await response.body;
+    const contentType = response.headers.get('content-type') || '';
+    let asyncIterator;
+    if (isIncomingMessage(body)) {
+        // Meros/node expects headers as an object map with the content-type prop
+        body.headers = {
+            'content-type': contentType,
+        };
+        // And it expects `IncomingMessage` and `node-fetch` returns `body` as `Promise<PassThrough>`
+        asyncIterator = (await merosIncomingMessage(body));
+    }
+    else {
+        // Nothing is needed for regular `Response`.
+        asyncIterator = (await merosReadableStream(response));
+    }
+    const executionResult = {};
+    return mapAsyncIterator(asyncIterator, (part) => {
+        if (part.json) {
+            const chunk = part.body;
+            if (chunk.path) {
+                if (chunk.data) {
+                    const path = ['data'];
+                    dset(executionResult, path.concat(chunk.path), chunk.data);
+                }
+                if (chunk.errors) {
+                    executionResult.errors = (executionResult.errors || []).concat(chunk.errors);
+                }
+            }
+            else {
+                if (chunk.data) {
+                    executionResult.data = chunk.data;
+                }
+                if (chunk.errors) {
+                    executionResult.errors = chunk.errors;
+                }
+            }
+            return executionResult;
+        }
+    });
+}

package/{index.mjs → esm/index.js}

@@ -1,279 +1,23 @@
+/* eslint-disable no-case-declarations */
+/// <reference lib="dom" />
 import { print, buildASTSchema, buildSchema } from 'graphql';
-import { mapAsyncIterator, isAsyncIterable, inspect, withCancel, observableToAsyncIterable, parseGraphQLSDL, getOperationASTFromRequest } from '@graphql-tools/utils';
+import { observableToAsyncIterable, isAsyncIterable, parseGraphQLSDL, getOperationASTFromRequest, } from '@graphql-tools/utils';
 import { introspectSchema, wrapSchema } from '@graphql-tools/wrap';
 import { createClient } from 'graphql-ws';
 import WebSocket from 'isomorphic-ws';
 import { extractFiles, isExtractableFile } from 'extract-files';
 import { ValueOrPromise } from 'value-or-promise';
 import { isLiveQueryOperationDefinitionNode } from '@n1ru4l/graphql-live-query';
-import { fetch, FormData, File, AbortController } from 'cross-undici-fetch';
-import syncFetchImported from 'sync-fetch';
-import { meros } from 'meros/node';
-import { meros as meros$1 } from 'meros/browser';
-import { dset } from 'dset/merge';
-
-const defaultAsyncFetch = async (input, init) => {
-    return fetch(input, init);
-};
-
-const defaultSyncFetch = (input, init) => {
-    if (typeof input === 'string') {
-        init === null || init === void 0 ? true : delete init.signal;
-    }
-    else {
-        delete input.signal;
-    }
-    return syncFetchImported(input, init);
-};
-
-function isIncomingMessage(body) {
-    return body != null && typeof body === 'object' && 'pipe' in body;
-}
-async function handleMultipartMixedResponse(response) {
-    const body = await response.body;
-    const contentType = response.headers.get('content-type') || '';
-    let asyncIterator;
-    if (isIncomingMessage(body)) {
-        // Meros/node expects headers as an object map with the content-type prop
-        body.headers = {
-            'content-type': contentType,
-        };
-        // And it expects `IncomingMessage` and `node-fetch` returns `body` as `Promise<PassThrough>`
-        asyncIterator = (await meros(body));
-    }
-    else {
-        // Nothing is needed for regular `Response`.
-        asyncIterator = (await meros$1(response));
-    }
-    const executionResult = {};
-    return mapAsyncIterator(asyncIterator, (part) => {
-        if (part.json) {
-            const chunk = part.body;
-            if (chunk.path) {
-                if (chunk.data) {
-                    const path = ['data'];
-                    dset(executionResult, path.concat(chunk.path), chunk.data);
-                }
-                if (chunk.errors) {
-                    executionResult.errors = (executionResult.errors || []).concat(chunk.errors);
-                }
-            }
-            else {
-                if (chunk.data) {
-                    executionResult.data = chunk.data;
-                }
-                if (chunk.errors) {
-                    executionResult.errors = chunk.errors;
-                }
-            }
-            return executionResult;
-        }
-    });
-}
-
-/* eslint-disable no-labels */
-let decodeUint8Array;
-if (globalThis.Buffer) {
-    decodeUint8Array = uint8Array => globalThis.Buffer.from(uint8Array).toString('utf-8');
-}
-else {
-    const textDecoder = new TextDecoder();
-    decodeUint8Array = uint8Array => textDecoder.decode(uint8Array);
-}
-async function* handleReadable(readable) {
-    outer: for await (const chunk of readable) {
-        const chunkStr = typeof chunk === 'string' ? chunk : decodeUint8Array(chunk);
-        for (const part of chunkStr.split('\n\n')) {
-            if (part) {
-                const eventStr = part.split('event: ')[1];
-                const dataStr = part.split('data: ')[1];
-                if (eventStr === 'complete') {
-                    break outer;
-                }
-                if (dataStr) {
-                    const data = JSON.parse(dataStr);
-                    yield data.payload || data;
-                }
-            }
-        }
-    }
-}
-
-// Based on https://github.com/Azure/fetch-event-source/blob/main/src/parse.ts
-async function* handleReadableStream(stream) {
-    const decoder = new TextDecoder();
-    const reader = stream.getReader();
-    let buffer;
-    let position = 0; // current read position
-    let fieldLength = -1; // length of the `field` portion of the line
-    let discardTrailingNewline = false;
-    try {
-        let result;
-        let message = {
-            data: '',
-            event: '',
-            id: '',
-            retry: undefined,
-        };
-        while (!(result = await reader.read()).done) {
-            const arr = result.value;
-            if (buffer === undefined) {
-                buffer = arr;
-                position = 0;
-                fieldLength = -1;
-            }
-            else {
-                // we're still parsing the old line. Append the new bytes into buffer:
-                buffer = concat(buffer, arr);
-            }
-            const bufLength = buffer.length;
-            let lineStart = 0; // index where the current line starts
-            while (position < bufLength) {
-                if (discardTrailingNewline) {
-                    if (buffer[position] === 10 /* ControlChars.NewLine */) {
-                        lineStart = ++position; // skip to next char
-                    }
-                    discardTrailingNewline = false;
-                }
-                // start looking forward till the end of line:
-                let lineEnd = -1; // index of the \r or \n char
-                for (; position < bufLength && lineEnd === -1; ++position) {
-                    switch (buffer[position]) {
-                        case 58 /* ControlChars.Colon */: {
-                            if (fieldLength === -1) {
-                                // first colon in line
-                                fieldLength = position - lineStart;
-                            }
-                            break;
-                        }
-                        case 13 /* ControlChars.CarriageReturn */: {
-                            discardTrailingNewline = true;
-                            break;
-                        }
-                        case 10 /* ControlChars.NewLine */: {
-                            lineEnd = position;
-                            break;
-                        }
-                    }
-                }
-                if (lineEnd === -1) {
-                    // We reached the end of the buffer but the line hasn't ended.
-                    // Wait for the next arr and then continue parsing:
-                    break;
-                }
-                // we've reached the line end, send it out:
-                const line = buffer.subarray(lineStart, lineEnd);
-                if (line.length === 0) {
-                    // empty line denotes end of message. Trigger the callback and start a new message:
-                    if (message.event || message.data) {
-                        // NOT a server ping (":\n\n")
-                        yield JSON.parse(message.data);
-                        message = {
-                            data: '',
-                            event: '',
-                            id: '',
-                            retry: undefined,
-                        };
-                    }
-                }
-                else if (fieldLength > 0) {
-                    // exclude comments and lines with no values
-                    // line is of format "<field>:<value>" or "<field>: <value>"
-                    // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
-                    const field = decoder.decode(line.subarray(0, fieldLength));
-                    const valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* ControlChars.Space */ ? 2 : 1);
-                    const value = decoder.decode(line.subarray(valueOffset));
-                    switch (field) {
-                        case 'data':
-                            // if this message already has data, append the new value to the old.
-                            // otherwise, just set to the new value:
-                            message.data = message.data ? message.data + '\n' + value : value; // otherwise,
-                            break;
-                        case 'event':
-                            message.event = value;
-                            break;
-                        case 'id':
-                            message.id = value;
-                            break;
-                        case 'retry': {
-                            const retry = parseInt(value, 10);
-                            message.retry = retry;
-                            break;
-                        }
-                    }
-                }
-                lineStart = position; // we're now on the next line
-                fieldLength = -1;
-            }
-            if (lineStart === bufLength) {
-                buffer = undefined; // we've finished reading it
-            }
-            else if (lineStart !== 0) {
-                // Create a new view into buffer beginning at lineStart so we don't
-                // need to copy over the previous lines when we get the new arr:
-                buffer = buffer.subarray(lineStart);
-                position -= lineStart;
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
-function concat(a, b) {
-    const res = new Uint8Array(a.length + b.length);
-    res.set(a);
-    res.set(b, a.length);
-    return res;
-}
-
-async function handleEventStreamResponse(response) {
-    // node-fetch returns body as a promise so we need to resolve it
-    const body = await response.body;
-    if (body) {
-        if (isAsyncIterable(body)) {
-            return handleReadable(body);
-        }
-        return handleReadableStream(body);
-    }
-    throw new Error('Response body is expected to be a readable stream but got; ' + inspect(body));
-}
-
-function addCancelToResponseStream(resultStream, controller) {
-    return withCancel(resultStream, () => {
-        if (!controller.signal.aborted) {
-            controller.abort();
-        }
-    });
-}
-
-function isBlob(obj) {
-    return typeof obj.arrayBuffer === 'function';
-}
-function isGraphQLUpload(upload) {
-    return typeof upload.createReadStream === 'function';
-}
-function isPromiseLike(obj) {
-    return typeof obj.then === 'function';
-}
-var LEGACY_WS;
-(function (LEGACY_WS) {
-    LEGACY_WS["CONNECTION_INIT"] = "connection_init";
-    LEGACY_WS["CONNECTION_ACK"] = "connection_ack";
-    LEGACY_WS["CONNECTION_ERROR"] = "connection_error";
-    LEGACY_WS["CONNECTION_KEEP_ALIVE"] = "ka";
-    LEGACY_WS["START"] = "start";
-    LEGACY_WS["STOP"] = "stop";
-    LEGACY_WS["CONNECTION_TERMINATE"] = "connection_terminate";
-    LEGACY_WS["DATA"] = "data";
-    LEGACY_WS["ERROR"] = "error";
-    LEGACY_WS["COMPLETE"] = "complete";
-})(LEGACY_WS || (LEGACY_WS = {}));
-
-/* eslint-disable no-case-declarations */
+import { defaultAsyncFetch } from './defaultAsyncFetch.js';
+import { defaultSyncFetch } from './defaultSyncFetch.js';
+import { handleMultipartMixedResponse } from './handleMultipartMixedResponse.js';
+import { handleEventStreamResponse } from './event-stream/handleEventStreamResponse.js';
+import { addCancelToResponseStream } from './addCancelToResponseStream.js';
+import { AbortController, FormData, File } from 'cross-undici-fetch';
+import { isBlob, isGraphQLUpload, isPromiseLike, LEGACY_WS } from './utils.js';
 const asyncImport = (moduleName) => import(moduleName);
 const syncImport = (moduleName) => require(moduleName);
-var SubscriptionProtocol;
+export var SubscriptionProtocol;
 (function (SubscriptionProtocol) {
     SubscriptionProtocol["WS"] = "WS";
     /**
@@ -311,7 +55,7 @@ function isCompatibleUri(uri) {
  * });
  * ```
  */
-class UrlLoader {
+export class UrlLoader {
     createFormDataFromVariables({ query, variables, operationName, extensions, }) {
         const vars = Object.assign({}, variables);
         const { clone, files } = extractFiles(vars, 'variables', ((v) => isExtractableFile(v) ||
@@ -866,5 +610,3 @@ class UrlLoader {
 function switchProtocols(pointer, protocolMap) {
     return Object.entries(protocolMap).reduce((prev, [source, target]) => prev.replace(`${source}://`, `${target}://`).replace(`${source}:\\`, `${target}:\\`), pointer);
 }
-
-export { SubscriptionProtocol, UrlLoader };

package/esm/utils.js

@@ -0,0 +1,22 @@
+export function isBlob(obj) {
+    return typeof obj.arrayBuffer === 'function';
+}
+export function isGraphQLUpload(upload) {
+    return typeof upload.createReadStream === 'function';
+}
+export function isPromiseLike(obj) {
+    return typeof obj.then === 'function';
+}
+export var LEGACY_WS;
+(function (LEGACY_WS) {
+    LEGACY_WS["CONNECTION_INIT"] = "connection_init";
+    LEGACY_WS["CONNECTION_ACK"] = "connection_ack";
+    LEGACY_WS["CONNECTION_ERROR"] = "connection_error";
+    LEGACY_WS["CONNECTION_KEEP_ALIVE"] = "ka";
+    LEGACY_WS["START"] = "start";
+    LEGACY_WS["STOP"] = "stop";
+    LEGACY_WS["CONNECTION_TERMINATE"] = "connection_terminate";
+    LEGACY_WS["DATA"] = "data";
+    LEGACY_WS["ERROR"] = "error";
+    LEGACY_WS["COMPLETE"] = "complete";
+})(LEGACY_WS || (LEGACY_WS = {}));