@graphql-tools/url-loader 7.12.2-alpha-b93d3b57.0 → 7.12.4

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 '@whatwg-node/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/esm/index.js

@@ -0,0 +1,607 @@
+/* eslint-disable no-case-declarations */
+/// <reference lib="dom" />
+import { print, buildASTSchema, buildSchema } from 'graphql';
+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 { 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 '@whatwg-node/fetch';
+import { isBlob, isGraphQLUpload, isPromiseLike, LEGACY_WS } from './utils.js';
+const asyncImport = (moduleName) => import(moduleName);
+const syncImport = (moduleName) => require(moduleName);
+export var SubscriptionProtocol;
+(function (SubscriptionProtocol) {
+    SubscriptionProtocol["WS"] = "WS";
+    /**
+     * Use legacy web socket protocol `graphql-ws` instead of the more current standard `graphql-transport-ws`
+     */
+    SubscriptionProtocol["LEGACY_WS"] = "LEGACY_WS";
+    /**
+     * Use SSE for subscription instead of WebSocket
+     */
+    SubscriptionProtocol["SSE"] = "SSE";
+    /**
+     * Use `graphql-sse` for subscriptions
+     */
+    SubscriptionProtocol["GRAPHQL_SSE"] = "GRAPHQL_SSE";
+})(SubscriptionProtocol || (SubscriptionProtocol = {}));
+function isCompatibleUri(uri) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(uri);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * This loader loads a schema from a URL. The loaded schema is a fully-executable,
+ * remote schema since it's created using [@graphql-tools/wrap](/docs/remote-schemas).
+ *
+ * ```
+ * const schema = await loadSchema('http://localhost:3000/graphql', {
+ *   loaders: [
+ *     new UrlLoader(),
+ *   ]
+ * });
+ * ```
+ */
+export class UrlLoader {
+    createFormDataFromVariables({ query, variables, operationName, extensions, }) {
+        const vars = Object.assign({}, variables);
+        const { clone, files } = extractFiles(vars, 'variables', ((v) => isExtractableFile(v) ||
+            (v === null || v === void 0 ? void 0 : v.promise) ||
+            isAsyncIterable(v) ||
+            (v === null || v === void 0 ? void 0 : v.then) ||
+            typeof (v === null || v === void 0 ? void 0 : v.arrayBuffer) === 'function'));
+        const map = {};
+        const uploads = [];
+        let currIndex = 0;
+        for (const [file, curr] of files) {
+            map[currIndex] = curr;
+            uploads[currIndex] = file;
+            currIndex++;
+        }
+        const form = new FormData();
+        form.append('operations', JSON.stringify({
+            query,
+            variables: clone,
+            operationName,
+            extensions,
+        }));
+        form.append('map', JSON.stringify(map));
+        function handleUpload(upload, i) {
+            const indexStr = i.toString();
+            if (upload != null) {
+                const filename = upload.filename || upload.name || upload.path || `blob-${indexStr}`;
+                if (isPromiseLike(upload)) {
+                    return upload.then((resolvedUpload) => handleUpload(resolvedUpload, i));
+                    // If Blob
+                }
+                else if (isBlob(upload)) {
+                    return upload.arrayBuffer().then((arrayBuffer) => {
+                        form.append(indexStr, new File([arrayBuffer], filename, { type: upload.type }), filename);
+                    });
+                }
+                else if (isGraphQLUpload(upload)) {
+                    const stream = upload.createReadStream();
+                    const chunks = [];
+                    return Promise.resolve().then(async () => {
+                        for await (const chunk of stream) {
+                            if (chunk) {
+                                chunks.push(...chunk);
+                            }
+                        }
+                        const blobPart = new Uint8Array(chunks);
+                        form.append(indexStr, new File([blobPart], filename, { type: upload.mimetype }), filename);
+                    });
+                }
+                else {
+                    form.append(indexStr, new File([upload], filename), filename);
+                }
+            }
+        }
+        return ValueOrPromise.all(uploads.map((upload, i) => new ValueOrPromise(() => handleUpload(upload, i))))
+            .then(() => form)
+            .resolve();
+    }
+    prepareGETUrl({ baseUrl, query, variables, operationName, extensions, }) {
+        const HTTP_URL = switchProtocols(baseUrl, {
+            wss: 'https',
+            ws: 'http',
+        });
+        const dummyHostname = 'https://dummyhostname.com';
+        const validUrl = HTTP_URL.startsWith('http')
+            ? HTTP_URL
+            : HTTP_URL.startsWith('/')
+                ? `${dummyHostname}${HTTP_URL}`
+                : `${dummyHostname}/${HTTP_URL}`;
+        const urlObj = new URL(validUrl);
+        urlObj.searchParams.set('query', query);
+        if (variables && Object.keys(variables).length > 0) {
+            urlObj.searchParams.set('variables', JSON.stringify(variables));
+        }
+        if (operationName) {
+            urlObj.searchParams.set('operationName', operationName);
+        }
+        if (extensions) {
+            urlObj.searchParams.set('extensions', JSON.stringify(extensions));
+        }
+        const finalUrl = urlObj.toString().replace(dummyHostname, '');
+        return finalUrl;
+    }
+    buildHTTPExecutor(initialEndpoint, fetch, options) {
+        const defaultMethod = this.getDefaultMethodFromOptions(options === null || options === void 0 ? void 0 : options.method, 'POST');
+        const HTTP_URL = switchProtocols(initialEndpoint, {
+            wss: 'https',
+            ws: 'http',
+        });
+        const executor = (request) => {
+            var _a, _b;
+            const controller = new AbortController();
+            let method = defaultMethod;
+            const operationAst = getOperationASTFromRequest(request);
+            const operationType = operationAst.operation;
+            if ((options === null || options === void 0 ? void 0 : options.useGETForQueries) && operationType === 'query') {
+                method = 'GET';
+            }
+            let accept = 'application/json, multipart/mixed';
+            if (operationType === 'subscription' || isLiveQueryOperationDefinitionNode(operationAst)) {
+                method = 'GET';
+                accept = 'text/event-stream';
+            }
+            const endpoint = ((_a = request.extensions) === null || _a === void 0 ? void 0 : _a.endpoint) || HTTP_URL;
+            const headers = Object.assign({
+                accept,
+            }, options === null || options === void 0 ? void 0 : options.headers, ((_b = request.extensions) === null || _b === void 0 ? void 0 : _b.headers) || {});
+            const query = print(request.document);
+            const requestBody = {
+                query,
+                variables: request.variables,
+                operationName: request.operationName,
+                extensions: request.extensions,
+            };
+            let timeoutId;
+            if (options === null || options === void 0 ? void 0 : options.timeout) {
+                timeoutId = setTimeout(() => {
+                    if (!controller.signal.aborted) {
+                        controller.abort();
+                    }
+                }, options.timeout);
+            }
+            const credentials = (options === null || options === void 0 ? void 0 : options.credentials) !== 'disable' ? (options === null || options === void 0 ? void 0 : options.credentials) || 'same-origin' : null;
+            return new ValueOrPromise(() => {
+                switch (method) {
+                    case 'GET':
+                        const finalUrl = this.prepareGETUrl({
+                            baseUrl: endpoint,
+                            ...requestBody,
+                        });
+                        return fetch(finalUrl, {
+                            method: 'GET',
+                            ...(credentials != null ? { credentials } : {}),
+                            headers,
+                            signal: controller.signal,
+                        });
+                    case 'POST':
+                        if (options === null || options === void 0 ? void 0 : options.multipart) {
+                            return new ValueOrPromise(() => this.createFormDataFromVariables(requestBody))
+                                .then(form => fetch(endpoint, {
+                                method: 'POST',
+                                ...(credentials != null ? { credentials } : {}),
+                                body: form,
+                                headers,
+                                signal: controller.signal,
+                            }))
+                                .resolve();
+                        }
+                        else {
+                            return fetch(endpoint, {
+                                method: 'POST',
+                                ...(credentials != null ? { credentials } : {}),
+                                body: JSON.stringify(requestBody),
+                                headers: {
+                                    'content-type': 'application/json',
+                                    ...headers,
+                                },
+                                signal: controller.signal,
+                            });
+                        }
+                }
+            })
+                .then((fetchResult) => {
+                if (timeoutId != null) {
+                    clearTimeout(timeoutId);
+                }
+                // Retry should respect HTTP Errors
+                if ((options === null || options === void 0 ? void 0 : options.retry) != null && !fetchResult.status.toString().startsWith('2')) {
+                    throw new Error(fetchResult.statusText || `HTTP Error: ${fetchResult.status}`);
+                }
+                const contentType = fetchResult.headers.get('content-type');
+                if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('text/event-stream')) {
+                    return handleEventStreamResponse(fetchResult).then(resultStream => addCancelToResponseStream(resultStream, controller));
+                }
+                else if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('multipart/mixed')) {
+                    return handleMultipartMixedResponse(fetchResult).then(resultStream => addCancelToResponseStream(resultStream, controller));
+                }
+                return fetchResult.text();
+            })
+                .then(result => {
+                if (typeof result === 'string') {
+                    if (result) {
+                        return JSON.parse(result);
+                    }
+                }
+                else {
+                    return result;
+                }
+            })
+                .resolve();
+        };
+        if ((options === null || options === void 0 ? void 0 : options.retry) != null) {
+            return function retryExecutor(request) {
+                let result;
+                let error;
+                let attempt = 0;
+                function retryAttempt() {
+                    attempt++;
+                    if (attempt > options.retry) {
+                        if (result != null) {
+                            return result;
+                        }
+                        if (error != null) {
+                            throw error;
+                        }
+                        throw new Error('No result');
+                    }
+                    return new ValueOrPromise(() => executor(request))
+                        .then(res => {
+                        var _a;
+                        result = res;
+                        if ((_a = result === null || result === void 0 ? void 0 : result.errors) === null || _a === void 0 ? void 0 : _a.length) {
+                            return retryAttempt();
+                        }
+                        return result;
+                    })
+                        .catch((e) => {
+                        error = e;
+                        return retryAttempt();
+                    })
+                        .resolve();
+                }
+                return retryAttempt();
+            };
+        }
+        return executor;
+    }
+    buildWSExecutor(subscriptionsEndpoint, webSocketImpl, connectionParams) {
+        const WS_URL = switchProtocols(subscriptionsEndpoint, {
+            https: 'wss',
+            http: 'ws',
+        });
+        const subscriptionClient = createClient({
+            url: WS_URL,
+            webSocketImpl,
+            connectionParams,
+            lazy: true,
+        });
+        return ({ document, variables, operationName, extensions }) => {
+            const query = print(document);
+            return observableToAsyncIterable({
+                subscribe: observer => {
+                    const unsubscribe = subscriptionClient.subscribe({
+                        query,
+                        variables: variables,
+                        operationName,
+                        extensions,
+                    }, observer);
+                    return {
+                        unsubscribe,
+                    };
+                },
+            });
+        };
+    }
+    buildWSLegacyExecutor(subscriptionsEndpoint, WebSocketImpl, options) {
+        const WS_URL = switchProtocols(subscriptionsEndpoint, {
+            https: 'wss',
+            http: 'ws',
+        });
+        const observerById = new Map();
+        let websocket = null;
+        const ensureWebsocket = () => {
+            websocket = new WebSocketImpl(WS_URL, 'graphql-ws', {
+                followRedirects: true,
+                headers: options === null || options === void 0 ? void 0 : options.headers,
+                rejectUnauthorized: false,
+                skipUTF8Validation: true,
+            });
+            websocket.onopen = () => {
+                let payload = {};
+                switch (typeof (options === null || options === void 0 ? void 0 : options.connectionParams)) {
+                    case 'function':
+                        payload = options === null || options === void 0 ? void 0 : options.connectionParams();
+                        break;
+                    case 'object':
+                        payload = options === null || options === void 0 ? void 0 : options.connectionParams;
+                        break;
+                }
+                websocket.send(JSON.stringify({
+                    type: LEGACY_WS.CONNECTION_INIT,
+                    payload,
+                }));
+            };
+        };
+        const cleanupWebsocket = () => {
+            if (websocket != null && observerById.size === 0) {
+                websocket.send(JSON.stringify({
+                    type: LEGACY_WS.CONNECTION_TERMINATE,
+                }));
+                websocket.terminate();
+                websocket = null;
+            }
+        };
+        return function legacyExecutor(request) {
+            const id = Date.now().toString();
+            return observableToAsyncIterable({
+                subscribe(observer) {
+                    ensureWebsocket();
+                    if (websocket == null) {
+                        throw new Error(`WebSocket connection is not found!`);
+                    }
+                    websocket.onmessage = event => {
+                        const data = JSON.parse(event.data.toString('utf-8'));
+                        switch (data.type) {
+                            case LEGACY_WS.CONNECTION_ACK: {
+                                if (websocket == null) {
+                                    throw new Error(`WebSocket connection is not found!`);
+                                }
+                                websocket.send(JSON.stringify({
+                                    type: LEGACY_WS.START,
+                                    id,
+                                    payload: {
+                                        query: print(request.document),
+                                        variables: request.variables,
+                                        operationName: request.operationName,
+                                    },
+                                }));
+                                break;
+                            }
+                            case LEGACY_WS.CONNECTION_ERROR: {
+                                observer.error(data.payload);
+                                break;
+                            }
+                            case LEGACY_WS.CONNECTION_KEEP_ALIVE: {
+                                break;
+                            }
+                            case LEGACY_WS.DATA: {
+                                observer.next(data.payload);
+                                break;
+                            }
+                            case LEGACY_WS.COMPLETE: {
+                                if (websocket == null) {
+                                    throw new Error(`WebSocket connection is not found!`);
+                                }
+                                websocket.send(JSON.stringify({
+                                    type: LEGACY_WS.CONNECTION_TERMINATE,
+                                }));
+                                observer.complete();
+                                cleanupWebsocket();
+                                break;
+                            }
+                        }
+                    };
+                    return {
+                        unsubscribe: () => {
+                            websocket === null || websocket === void 0 ? void 0 : websocket.send(JSON.stringify({
+                                type: LEGACY_WS.STOP,
+                                id,
+                            }));
+                            cleanupWebsocket();
+                        },
+                    };
+                },
+            });
+        };
+    }
+    getFetch(customFetch, importFn) {
+        if (customFetch) {
+            if (typeof customFetch === 'string') {
+                const [moduleName, fetchFnName] = customFetch.split('#');
+                return new ValueOrPromise(() => importFn(moduleName))
+                    .then(module => (fetchFnName ? module[fetchFnName] : module))
+                    .resolve();
+            }
+            else if (typeof customFetch === 'function') {
+                return customFetch;
+            }
+        }
+        if (importFn === asyncImport) {
+            return defaultAsyncFetch;
+        }
+        else {
+            return defaultSyncFetch;
+        }
+    }
+    getDefaultMethodFromOptions(method, defaultMethod) {
+        if (method) {
+            defaultMethod = method;
+        }
+        return defaultMethod;
+    }
+    getWebSocketImpl(importFn, options) {
+        if (typeof (options === null || options === void 0 ? void 0 : options.webSocketImpl) === 'string') {
+            const [moduleName, webSocketImplName] = options.webSocketImpl.split('#');
+            return new ValueOrPromise(() => importFn(moduleName))
+                .then(importedModule => (webSocketImplName ? importedModule[webSocketImplName] : importedModule))
+                .resolve();
+        }
+        else {
+            const websocketImpl = (options === null || options === void 0 ? void 0 : options.webSocketImpl) || WebSocket;
+            return websocketImpl;
+        }
+    }
+    buildSubscriptionExecutor(subscriptionsEndpoint, fetch, importFn, options) {
+        if ((options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) === SubscriptionProtocol.SSE) {
+            return this.buildHTTPExecutor(subscriptionsEndpoint, fetch, options);
+        }
+        else if ((options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) === SubscriptionProtocol.GRAPHQL_SSE) {
+            if (!(options === null || options === void 0 ? void 0 : options.subscriptionsEndpoint)) {
+                // when no custom subscriptions endpoint is specified,
+                // graphql-sse is recommended to be used on `/graphql/stream`
+                subscriptionsEndpoint += '/stream';
+            }
+            return this.buildHTTPExecutor(subscriptionsEndpoint, fetch, options);
+        }
+        else {
+            const webSocketImpl$ = new ValueOrPromise(() => this.getWebSocketImpl(importFn, options));
+            const executor$ = webSocketImpl$.then(webSocketImpl => {
+                if ((options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) === SubscriptionProtocol.LEGACY_WS) {
+                    return this.buildWSLegacyExecutor(subscriptionsEndpoint, webSocketImpl, options);
+                }
+                else {
+                    return this.buildWSExecutor(subscriptionsEndpoint, webSocketImpl, options === null || options === void 0 ? void 0 : options.connectionParams);
+                }
+            });
+            return request => executor$.then(executor => executor(request)).resolve();
+        }
+    }
+    getExecutor(endpoint, importFn, options) {
+        const fetch$ = new ValueOrPromise(() => this.getFetch(options === null || options === void 0 ? void 0 : options.customFetch, importFn));
+        const httpExecutor$ = fetch$.then(fetch => {
+            return this.buildHTTPExecutor(endpoint, fetch, options);
+        });
+        if ((options === null || options === void 0 ? void 0 : options.subscriptionsEndpoint) != null || (options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) !== SubscriptionProtocol.SSE) {
+            const subscriptionExecutor$ = fetch$.then(fetch => {
+                const subscriptionsEndpoint = (options === null || options === void 0 ? void 0 : options.subscriptionsEndpoint) || endpoint;
+                return this.buildSubscriptionExecutor(subscriptionsEndpoint, fetch, importFn, options);
+            });
+            // eslint-disable-next-line no-inner-declarations
+            function getExecutorByRequest(request) {
+                const operationAst = getOperationASTFromRequest(request);
+                if (operationAst.operation === 'subscription' ||
+                    isLiveQueryOperationDefinitionNode(operationAst, request.variables)) {
+                    return subscriptionExecutor$;
+                }
+                else {
+                    return httpExecutor$;
+                }
+            }
+            return request => getExecutorByRequest(request)
+                .then(executor => executor(request))
+                .resolve();
+        }
+        else {
+            return request => httpExecutor$.then(executor => executor(request)).resolve();
+        }
+    }
+    getExecutorAsync(endpoint, options) {
+        return this.getExecutor(endpoint, asyncImport, options);
+    }
+    getExecutorSync(endpoint, options) {
+        return this.getExecutor(endpoint, syncImport, options);
+    }
+    handleSDL(pointer, fetch, options) {
+        const defaultMethod = this.getDefaultMethodFromOptions(options === null || options === void 0 ? void 0 : options.method, 'GET');
+        return new ValueOrPromise(() => fetch(pointer, {
+            method: defaultMethod,
+            headers: options.headers,
+        }))
+            .then(response => response.text())
+            .then(schemaString => parseGraphQLSDL(pointer, schemaString, options))
+            .resolve();
+    }
+    async load(pointer, options) {
+        if (!isCompatibleUri(pointer)) {
+            return [];
+        }
+        let source = {
+            location: pointer,
+        };
+        let executor;
+        if ((options === null || options === void 0 ? void 0 : options.handleAsSDL) || pointer.endsWith('.graphql') || pointer.endsWith('.graphqls')) {
+            const fetch = await this.getFetch(options === null || options === void 0 ? void 0 : options.customFetch, asyncImport);
+            source = await this.handleSDL(pointer, fetch, options);
+            if (!source.schema && !source.document && !source.rawSDL) {
+                throw new Error(`Invalid SDL response`);
+            }
+            source.schema =
+                source.schema ||
+                    (source.document
+                        ? buildASTSchema(source.document, options)
+                        : source.rawSDL
+                            ? buildSchema(source.rawSDL, options)
+                            : undefined);
+        }
+        else {
+            executor = this.getExecutorAsync(pointer, options);
+            source.schema = await introspectSchema(executor, {}, options);
+        }
+        if (!source.schema) {
+            throw new Error(`Invalid introspected schema`);
+        }
+        if (options === null || options === void 0 ? void 0 : options.endpoint) {
+            executor = this.getExecutorAsync(options.endpoint, options);
+        }
+        if (executor) {
+            source.schema = wrapSchema({
+                schema: source.schema,
+                executor,
+                batch: options === null || options === void 0 ? void 0 : options.batch,
+            });
+        }
+        return [source];
+    }
+    loadSync(pointer, options) {
+        if (!isCompatibleUri(pointer)) {
+            return [];
+        }
+        let source = {
+            location: pointer,
+        };
+        let executor;
+        if ((options === null || options === void 0 ? void 0 : options.handleAsSDL) || pointer.endsWith('.graphql') || pointer.endsWith('.graphqls')) {
+            const fetch = this.getFetch(options === null || options === void 0 ? void 0 : options.customFetch, syncImport);
+            source = this.handleSDL(pointer, fetch, options);
+            if (!source.schema && !source.document && !source.rawSDL) {
+                throw new Error(`Invalid SDL response`);
+            }
+            source.schema =
+                source.schema ||
+                    (source.document
+                        ? buildASTSchema(source.document, options)
+                        : source.rawSDL
+                            ? buildSchema(source.rawSDL, options)
+                            : undefined);
+        }
+        else {
+            executor = this.getExecutorSync(pointer, options);
+            source.schema = introspectSchema(executor, {}, options);
+        }
+        if (!source.schema) {
+            throw new Error(`Invalid introspected schema`);
+        }
+        if (options === null || options === void 0 ? void 0 : options.endpoint) {
+            executor = this.getExecutorSync(options.endpoint, options);
+        }
+        if (executor) {
+            source.schema = wrapSchema({
+                schema: source.schema,
+                executor,
+            });
+        }
+        return [source];
+    }
+}
+function switchProtocols(pointer, protocolMap) {
+    return Object.entries(protocolMap).reduce((prev, [source, target]) => prev.replace(`${source}://`, `${target}://`).replace(`${source}:\\`, `${target}:\\`), pointer);
+}

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 = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/url-loader",
-  "version": "7.12.2-alpha-b93d3b57.0",
+  "version": "7.12.4",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {

package/typings/addCancelToResponseStream.d.ts

@@ -0,0 +1 @@
+export declare function addCancelToResponseStream<T>(resultStream: AsyncIterable<T>, controller: AbortController): AsyncIterable<T>;

package/typings/defaultAsyncFetch.d.ts

@@ -0,0 +1,3 @@
+import { fetch } from '@whatwg-node/fetch';
+export declare type AsyncFetchFn = typeof fetch;
+export declare const defaultAsyncFetch: AsyncFetchFn;

package/typings/defaultSyncFetch.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultSyncFetch: SyncFetchFn;
+export declare type SyncFetchFn = (input: RequestInfo, init?: RequestInit) => SyncResponse;
+export declare type SyncResponse = Omit<Response, 'json' | 'text'> & {
+    json: () => any;
+    text: () => string;
+};

package/typings/event-stream/handleEventStreamResponse.d.ts

@@ -0,0 +1,2 @@
+import { ExecutionResult } from 'graphql';
+export declare function handleEventStreamResponse(response: Response): Promise<AsyncGenerator<ExecutionResult>>;

package/typings/event-stream/handleReadable.d.ts

@@ -0,0 +1 @@
+export declare function handleReadable(readable: AsyncIterable<Uint8Array | string>): AsyncGenerator<any, void, unknown>;

package/typings/event-stream/handleReadableStream.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Represents a message sent in an event stream
+ * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format
+ */
+export interface EventSourceMessage {
+    /** The event ID to set the EventSource object's last event ID value. */
+    id: string;
+    /** A string identifying the type of event described. */
+    event: string;
+    /** The event data */
+    data: string;
+    /** The reconnection interval (in milliseconds) to wait before retrying the connection */
+    retry?: number;
+}
+export declare function handleReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<any, void, unknown>;

package/typings/handleMultipartMixedResponse.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutionResult } from 'graphql';
+export declare function handleMultipartMixedResponse(response: Response): Promise<AsyncIterableIterator<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>> | undefined>>;

package/typings/index.d.ts

@@ -0,0 +1,151 @@
+/// <reference types="ws" />
+/// <reference lib="dom" />
+import { IntrospectionOptions } from 'graphql';
+import { AsyncExecutor, Executor, SyncExecutor, Source, Loader, BaseLoaderOptions } from '@graphql-tools/utils';
+import { ClientOptions } from 'graphql-ws';
+import WebSocket from 'isomorphic-ws';
+import { AsyncFetchFn } from './defaultAsyncFetch.js';
+import { SyncFetchFn } from './defaultSyncFetch.js';
+export declare type FetchFn = AsyncFetchFn | SyncFetchFn;
+export declare type AsyncImportFn = (moduleName: string) => PromiseLike<any>;
+export declare type SyncImportFn = (moduleName: string) => any;
+declare type HeadersConfig = Record<string, string>;
+interface ExecutionExtensions {
+    headers?: HeadersConfig;
+    endpoint?: string;
+}
+export declare enum SubscriptionProtocol {
+    WS = "WS",
+    /**
+     * Use legacy web socket protocol `graphql-ws` instead of the more current standard `graphql-transport-ws`
+     */
+    LEGACY_WS = "LEGACY_WS",
+    /**
+     * Use SSE for subscription instead of WebSocket
+     */
+    SSE = "SSE",
+    /**
+     * Use `graphql-sse` for subscriptions
+     */
+    GRAPHQL_SSE = "GRAPHQL_SSE"
+}
+/**
+ * Additional options for loading from a URL
+ */
+export interface LoadFromUrlOptions extends BaseLoaderOptions, Partial<IntrospectionOptions> {
+    /**
+     * Additional headers to include when querying the original schema
+     */
+    headers?: HeadersConfig;
+    /**
+     * A custom `fetch` implementation to use when querying the original schema.
+     * Defaults to `cross-fetch`
+     */
+    customFetch?: FetchFn | string;
+    /**
+     * HTTP method to use when querying the original schema.
+     */
+    method?: 'GET' | 'POST';
+    /**
+     * Custom WebSocket implementation used by the loaded schema if subscriptions
+     * are enabled
+     */
+    webSocketImpl?: typeof WebSocket | string;
+    /**
+     * Whether to use the GET HTTP method for queries when querying the original schema
+     */
+    useGETForQueries?: boolean;
+    /**
+     * Use multipart for POST requests
+     */
+    multipart?: boolean;
+    /**
+     * Handle URL as schema SDL
+     */
+    handleAsSDL?: boolean;
+    /**
+     * Regular HTTP endpoint; defaults to the pointer
+     */
+    endpoint?: string;
+    /**
+     * Subscriptions endpoint; defaults to the endpoint given as HTTP endpoint
+     */
+    subscriptionsEndpoint?: string;
+    /**
+     * Use specific protocol for subscriptions
+     */
+    subscriptionsProtocol?: SubscriptionProtocol;
+    /**
+     * @deprecated This is no longer used. Will be removed in the next release
+     */
+    graphqlSseOptions?: any;
+    /**
+     * Retry attempts
+     */
+    retry?: number;
+    /**
+     * Timeout in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Request Credentials (default: 'same-origin')
+     * You can pass `disable` if you don't want this to be set in `Request`
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/credentials
+     */
+    credentials?: RequestCredentials | 'disable';
+    /**
+     * Connection Parameters for WebSockets connection
+     */
+    connectionParams?: any;
+    /**
+     * Enable Batching
+     */
+    batch?: boolean;
+}
+/**
+ * This loader loads a schema from a URL. The loaded schema is a fully-executable,
+ * remote schema since it's created using [@graphql-tools/wrap](/docs/remote-schemas).
+ *
+ * ```
+ * const schema = await loadSchema('http://localhost:3000/graphql', {
+ *   loaders: [
+ *     new UrlLoader(),
+ *   ]
+ * });
+ * ```
+ */
+export declare class UrlLoader implements Loader<LoadFromUrlOptions> {
+    createFormDataFromVariables<TVariables>({ query, variables, operationName, extensions, }: {
+        query: string;
+        variables: TVariables;
+        operationName?: string;
+        extensions?: any;
+    }): FormData | Promise<FormData>;
+    prepareGETUrl({ baseUrl, query, variables, operationName, extensions, }: {
+        baseUrl: string;
+        query: string;
+        variables: any;
+        operationName?: string;
+        extensions?: any;
+    }): string;
+    buildHTTPExecutor(endpoint: string, fetch: SyncFetchFn, options?: LoadFromUrlOptions): SyncExecutor<any, ExecutionExtensions>;
+    buildHTTPExecutor(endpoint: string, fetch: AsyncFetchFn, options?: LoadFromUrlOptions): AsyncExecutor<any, ExecutionExtensions>;
+    buildWSExecutor(subscriptionsEndpoint: string, webSocketImpl: typeof WebSocket, connectionParams?: ClientOptions['connectionParams']): Executor;
+    buildWSLegacyExecutor(subscriptionsEndpoint: string, WebSocketImpl: typeof WebSocket, options?: LoadFromUrlOptions): Executor;
+    getFetch(customFetch: LoadFromUrlOptions['customFetch'], importFn: AsyncImportFn): PromiseLike<AsyncFetchFn> | AsyncFetchFn;
+    getFetch(customFetch: LoadFromUrlOptions['customFetch'], importFn: SyncImportFn): SyncFetchFn;
+    private getDefaultMethodFromOptions;
+    getWebSocketImpl(importFn: AsyncImportFn, options?: LoadFromUrlOptions): PromiseLike<typeof WebSocket>;
+    getWebSocketImpl(importFn: SyncImportFn, options?: LoadFromUrlOptions): typeof WebSocket;
+    buildSubscriptionExecutor(subscriptionsEndpoint: string, fetch: SyncFetchFn, syncImport: SyncImportFn, options?: LoadFromUrlOptions): SyncExecutor;
+    buildSubscriptionExecutor(subscriptionsEndpoint: string, fetch: AsyncFetchFn, asyncImport: AsyncImportFn, options?: LoadFromUrlOptions): AsyncExecutor;
+    getExecutor(endpoint: string, asyncImport: AsyncImportFn, options?: Omit<LoadFromUrlOptions, 'endpoint'>): AsyncExecutor;
+    getExecutor(endpoint: string, syncImport: SyncImportFn, options?: Omit<LoadFromUrlOptions, 'endpoint'>): SyncExecutor;
+    getExecutorAsync(endpoint: string, options?: Omit<LoadFromUrlOptions, 'endpoint'>): AsyncExecutor;
+    getExecutorSync(endpoint: string, options?: Omit<LoadFromUrlOptions, 'endpoint'>): SyncExecutor;
+    handleSDL(pointer: string, fetch: SyncFetchFn, options: LoadFromUrlOptions): Source;
+    handleSDL(pointer: string, fetch: AsyncFetchFn, options: LoadFromUrlOptions): Promise<Source>;
+    load(pointer: string, options: LoadFromUrlOptions): Promise<Source[]>;
+    loadSync(pointer: string, options: LoadFromUrlOptions): Source[];
+}
+export {};

package/typings/utils.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import type { Readable } from 'stream';
+export declare function isBlob(obj: any): obj is Blob;
+interface GraphQLUpload {
+    filename: string;
+    mimetype: string;
+    createReadStream: () => Readable;
+}
+export declare function isGraphQLUpload(upload: any): upload is GraphQLUpload;
+export declare function isPromiseLike(obj: any): obj is PromiseLike<any>;
+export declare enum LEGACY_WS {
+    CONNECTION_INIT = "connection_init",
+    CONNECTION_ACK = "connection_ack",
+    CONNECTION_ERROR = "connection_error",
+    CONNECTION_KEEP_ALIVE = "ka",
+    START = "start",
+    STOP = "stop",
+    CONNECTION_TERMINATE = "connection_terminate",
+    DATA = "data",
+    ERROR = "error",
+    COMPLETE = "complete"
+}
+export {};