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

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/{cjs → esm}/event-stream/handleReadable.js

@@ -1,7 +1,4 @@
-"use strict";
 /* eslint-disable no-labels */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleReadable = void 0;
 let decodeUint8Array;
 if (globalThis.Buffer) {
     decodeUint8Array = uint8Array => globalThis.Buffer.from(uint8Array).toString('utf-8');
@@ -10,7 +7,7 @@ else {
     const textDecoder = new TextDecoder();
     decodeUint8Array = uint8Array => textDecoder.decode(uint8Array);
 }
-async function* handleReadable(readable) {
+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')) {
@@ -28,4 +25,3 @@ async function* handleReadable(readable) {
         }
     }
 }
-exports.handleReadable = handleReadable;

package/{cjs → esm}/event-stream/handleReadableStream.js

@@ -1,8 +1,5 @@
-"use strict";
 // Based on https://github.com/Azure/fetch-event-source/blob/main/src/parse.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleReadableStream = void 0;
-async function* handleReadableStream(stream) {
+export async function* handleReadableStream(stream) {
     const decoder = new TextDecoder();
     const reader = stream.getReader();
     let buffer;
@@ -122,7 +119,6 @@ async function* handleReadableStream(stream) {
         reader.releaseLock();
     }
 }
-exports.handleReadableStream = handleReadableStream;
 function concat(a, b) {
     const res = new Uint8Array(a.length + b.length);
     res.set(a);

package/{cjs → esm}/handleMultipartMixedResponse.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMultipartMixedResponse = void 0;
-const node_1 = require("meros/node");
-const browser_1 = require("meros/browser");
-const utils_1 = require("@graphql-tools/utils");
-const merge_1 = require("dset/merge");
+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;
 }
-async function handleMultipartMixedResponse(response) {
+export async function handleMultipartMixedResponse(response) {
     const body = await response.body;
     const contentType = response.headers.get('content-type') || '';
     let asyncIterator;
@@ -18,20 +15,20 @@ async function handleMultipartMixedResponse(response) {
             'content-type': contentType,
         };
         // And it expects `IncomingMessage` and `node-fetch` returns `body` as `Promise<PassThrough>`
-        asyncIterator = (await (0, node_1.meros)(body));
+        asyncIterator = (await merosIncomingMessage(body));
     }
     else {
         // Nothing is needed for regular `Response`.
-        asyncIterator = (await (0, browser_1.meros)(response));
+        asyncIterator = (await merosReadableStream(response));
     }
     const executionResult = {};
-    return (0, utils_1.mapAsyncIterator)(asyncIterator, (part) => {
+    return mapAsyncIterator(asyncIterator, (part) => {
         if (part.json) {
             const chunk = part.body;
             if (chunk.path) {
                 if (chunk.data) {
                     const path = ['data'];
-                    (0, merge_1.dset)(executionResult, path.concat(chunk.path), chunk.data);
+                    dset(executionResult, path.concat(chunk.path), chunk.data);
                 }
                 if (chunk.errors) {
                     executionResult.errors = (executionResult.errors || []).concat(chunk.errors);
@@ -49,4 +46,3 @@ async function handleMultipartMixedResponse(response) {
         }
     });
 }
-exports.handleMultipartMixedResponse = handleMultipartMixedResponse;

package/{cjs → esm}/index.js

@@ -1,27 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UrlLoader = exports.SubscriptionProtocol = void 0;
-const tslib_1 = require("tslib");
 /* eslint-disable no-case-declarations */
 /// <reference lib="dom" />
-const graphql_1 = require("graphql");
-const utils_1 = require("@graphql-tools/utils");
-const wrap_1 = require("@graphql-tools/wrap");
-const graphql_ws_1 = require("graphql-ws");
-const isomorphic_ws_1 = tslib_1.__importDefault(require("isomorphic-ws"));
-const extract_files_1 = require("extract-files");
-const value_or_promise_1 = require("value-or-promise");
-const graphql_live_query_1 = require("@n1ru4l/graphql-live-query");
-const defaultAsyncFetch_js_1 = require("./defaultAsyncFetch.js");
-const defaultSyncFetch_js_1 = require("./defaultSyncFetch.js");
-const handleMultipartMixedResponse_js_1 = require("./handleMultipartMixedResponse.js");
-const handleEventStreamResponse_js_1 = require("./event-stream/handleEventStreamResponse.js");
-const addCancelToResponseStream_js_1 = require("./addCancelToResponseStream.js");
-const fetch_1 = require("@whatwg-node/fetch");
-const utils_js_1 = require("./utils.js");
-const asyncImport = (moduleName) => Promise.resolve().then(() => tslib_1.__importStar(require(moduleName)));
+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);
-var SubscriptionProtocol;
+export var SubscriptionProtocol;
 (function (SubscriptionProtocol) {
     SubscriptionProtocol["WS"] = "WS";
     /**
@@ -36,7 +32,7 @@ var SubscriptionProtocol;
      * Use `graphql-sse` for subscriptions
      */
     SubscriptionProtocol["GRAPHQL_SSE"] = "GRAPHQL_SSE";
-})(SubscriptionProtocol = exports.SubscriptionProtocol || (exports.SubscriptionProtocol = {}));
+})(SubscriptionProtocol || (SubscriptionProtocol = {}));
 function isCompatibleUri(uri) {
     try {
         // eslint-disable-next-line no-new
@@ -59,12 +55,12 @@ function isCompatibleUri(uri) {
  * });
  * ```
  */
-class UrlLoader {
+export class UrlLoader {
     createFormDataFromVariables({ query, variables, operationName, extensions, }) {
         const vars = Object.assign({}, variables);
-        const { clone, files } = (0, extract_files_1.extractFiles)(vars, 'variables', ((v) => (0, extract_files_1.isExtractableFile)(v) ||
+        const { clone, files } = extractFiles(vars, 'variables', ((v) => isExtractableFile(v) ||
             (v === null || v === void 0 ? void 0 : v.promise) ||
-            (0, utils_1.isAsyncIterable)(v) ||
+            isAsyncIterable(v) ||
             (v === null || v === void 0 ? void 0 : v.then) ||
             typeof (v === null || v === void 0 ? void 0 : v.arrayBuffer) === 'function'));
         const map = {};
@@ -75,7 +71,7 @@ class UrlLoader {
             uploads[currIndex] = file;
             currIndex++;
         }
-        const form = new fetch_1.FormData();
+        const form = new FormData();
         form.append('operations', JSON.stringify({
             query,
             variables: clone,
@@ -87,16 +83,16 @@ class UrlLoader {
             const indexStr = i.toString();
             if (upload != null) {
                 const filename = upload.filename || upload.name || upload.path || `blob-${indexStr}`;
-                if ((0, utils_js_1.isPromiseLike)(upload)) {
+                if (isPromiseLike(upload)) {
                     return upload.then((resolvedUpload) => handleUpload(resolvedUpload, i));
                     // If Blob
                 }
-                else if ((0, utils_js_1.isBlob)(upload)) {
+                else if (isBlob(upload)) {
                     return upload.arrayBuffer().then((arrayBuffer) => {
-                        form.append(indexStr, new fetch_1.File([arrayBuffer], filename, { type: upload.type }), filename);
+                        form.append(indexStr, new File([arrayBuffer], filename, { type: upload.type }), filename);
                     });
                 }
-                else if ((0, utils_js_1.isGraphQLUpload)(upload)) {
+                else if (isGraphQLUpload(upload)) {
                     const stream = upload.createReadStream();
                     const chunks = [];
                     return Promise.resolve().then(async () => {
@@ -106,15 +102,15 @@ class UrlLoader {
                             }
                         }
                         const blobPart = new Uint8Array(chunks);
-                        form.append(indexStr, new fetch_1.File([blobPart], filename, { type: upload.mimetype }), filename);
+                        form.append(indexStr, new File([blobPart], filename, { type: upload.mimetype }), filename);
                     });
                 }
                 else {
-                    form.append(indexStr, new fetch_1.File([upload], filename), filename);
+                    form.append(indexStr, new File([upload], filename), filename);
                 }
             }
         }
-        return value_or_promise_1.ValueOrPromise.all(uploads.map((upload, i) => new value_or_promise_1.ValueOrPromise(() => handleUpload(upload, i))))
+        return ValueOrPromise.all(uploads.map((upload, i) => new ValueOrPromise(() => handleUpload(upload, i))))
             .then(() => form)
             .resolve();
     }
@@ -151,15 +147,15 @@ class UrlLoader {
         });
         const executor = (request) => {
             var _a, _b;
-            const controller = new fetch_1.AbortController();
+            const controller = new AbortController();
             let method = defaultMethod;
-            const operationAst = (0, utils_1.getOperationASTFromRequest)(request);
+            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' || (0, graphql_live_query_1.isLiveQueryOperationDefinitionNode)(operationAst)) {
+            if (operationType === 'subscription' || isLiveQueryOperationDefinitionNode(operationAst)) {
                 method = 'GET';
                 accept = 'text/event-stream';
             }
@@ -167,7 +163,7 @@ class UrlLoader {
             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 = (0, graphql_1.print)(request.document);
+            const query = print(request.document);
             const requestBody = {
                 query,
                 variables: request.variables,
@@ -183,7 +179,7 @@ class UrlLoader {
                 }, 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 value_or_promise_1.ValueOrPromise(() => {
+            return new ValueOrPromise(() => {
                 switch (method) {
                     case 'GET':
                         const finalUrl = this.prepareGETUrl({
@@ -198,7 +194,7 @@ class UrlLoader {
                         });
                     case 'POST':
                         if (options === null || options === void 0 ? void 0 : options.multipart) {
-                            return new value_or_promise_1.ValueOrPromise(() => this.createFormDataFromVariables(requestBody))
+                            return new ValueOrPromise(() => this.createFormDataFromVariables(requestBody))
                                 .then(form => fetch(endpoint, {
                                 method: 'POST',
                                 ...(credentials != null ? { credentials } : {}),
@@ -232,10 +228,10 @@ class UrlLoader {
                 }
                 const contentType = fetchResult.headers.get('content-type');
                 if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('text/event-stream')) {
-                    return (0, handleEventStreamResponse_js_1.handleEventStreamResponse)(fetchResult).then(resultStream => (0, addCancelToResponseStream_js_1.addCancelToResponseStream)(resultStream, controller));
+                    return handleEventStreamResponse(fetchResult).then(resultStream => addCancelToResponseStream(resultStream, controller));
                 }
                 else if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('multipart/mixed')) {
-                    return (0, handleMultipartMixedResponse_js_1.handleMultipartMixedResponse)(fetchResult).then(resultStream => (0, addCancelToResponseStream_js_1.addCancelToResponseStream)(resultStream, controller));
+                    return handleMultipartMixedResponse(fetchResult).then(resultStream => addCancelToResponseStream(resultStream, controller));
                 }
                 return fetchResult.text();
             })
@@ -267,7 +263,7 @@ class UrlLoader {
                         }
                         throw new Error('No result');
                     }
-                    return new value_or_promise_1.ValueOrPromise(() => executor(request))
+                    return new ValueOrPromise(() => executor(request))
                         .then(res => {
                         var _a;
                         result = res;
@@ -292,15 +288,15 @@ class UrlLoader {
             https: 'wss',
             http: 'ws',
         });
-        const subscriptionClient = (0, graphql_ws_1.createClient)({
+        const subscriptionClient = createClient({
             url: WS_URL,
             webSocketImpl,
             connectionParams,
             lazy: true,
         });
         return ({ document, variables, operationName, extensions }) => {
-            const query = (0, graphql_1.print)(document);
-            return (0, utils_1.observableToAsyncIterable)({
+            const query = print(document);
+            return observableToAsyncIterable({
                 subscribe: observer => {
                     const unsubscribe = subscriptionClient.subscribe({
                         query,
@@ -340,7 +336,7 @@ class UrlLoader {
                         break;
                 }
                 websocket.send(JSON.stringify({
-                    type: utils_js_1.LEGACY_WS.CONNECTION_INIT,
+                    type: LEGACY_WS.CONNECTION_INIT,
                     payload,
                 }));
             };
@@ -348,7 +344,7 @@ class UrlLoader {
         const cleanupWebsocket = () => {
             if (websocket != null && observerById.size === 0) {
                 websocket.send(JSON.stringify({
-                    type: utils_js_1.LEGACY_WS.CONNECTION_TERMINATE,
+                    type: LEGACY_WS.CONNECTION_TERMINATE,
                 }));
                 websocket.terminate();
                 websocket = null;
@@ -356,7 +352,7 @@ class UrlLoader {
         };
         return function legacyExecutor(request) {
             const id = Date.now().toString();
-            return (0, utils_1.observableToAsyncIterable)({
+            return observableToAsyncIterable({
                 subscribe(observer) {
                     ensureWebsocket();
                     if (websocket == null) {
@@ -365,38 +361,38 @@ class UrlLoader {
                     websocket.onmessage = event => {
                         const data = JSON.parse(event.data.toString('utf-8'));
                         switch (data.type) {
-                            case utils_js_1.LEGACY_WS.CONNECTION_ACK: {
+                            case LEGACY_WS.CONNECTION_ACK: {
                                 if (websocket == null) {
                                     throw new Error(`WebSocket connection is not found!`);
                                 }
                                 websocket.send(JSON.stringify({
-                                    type: utils_js_1.LEGACY_WS.START,
+                                    type: LEGACY_WS.START,
                                     id,
                                     payload: {
-                                        query: (0, graphql_1.print)(request.document),
+                                        query: print(request.document),
                                         variables: request.variables,
                                         operationName: request.operationName,
                                     },
                                 }));
                                 break;
                             }
-                            case utils_js_1.LEGACY_WS.CONNECTION_ERROR: {
+                            case LEGACY_WS.CONNECTION_ERROR: {
                                 observer.error(data.payload);
                                 break;
                             }
-                            case utils_js_1.LEGACY_WS.CONNECTION_KEEP_ALIVE: {
+                            case LEGACY_WS.CONNECTION_KEEP_ALIVE: {
                                 break;
                             }
-                            case utils_js_1.LEGACY_WS.DATA: {
+                            case LEGACY_WS.DATA: {
                                 observer.next(data.payload);
                                 break;
                             }
-                            case utils_js_1.LEGACY_WS.COMPLETE: {
+                            case LEGACY_WS.COMPLETE: {
                                 if (websocket == null) {
                                     throw new Error(`WebSocket connection is not found!`);
                                 }
                                 websocket.send(JSON.stringify({
-                                    type: utils_js_1.LEGACY_WS.CONNECTION_TERMINATE,
+                                    type: LEGACY_WS.CONNECTION_TERMINATE,
                                 }));
                                 observer.complete();
                                 cleanupWebsocket();
@@ -407,7 +403,7 @@ class UrlLoader {
                     return {
                         unsubscribe: () => {
                             websocket === null || websocket === void 0 ? void 0 : websocket.send(JSON.stringify({
-                                type: utils_js_1.LEGACY_WS.STOP,
+                                type: LEGACY_WS.STOP,
                                 id,
                             }));
                             cleanupWebsocket();
@@ -421,7 +417,7 @@ class UrlLoader {
         if (customFetch) {
             if (typeof customFetch === 'string') {
                 const [moduleName, fetchFnName] = customFetch.split('#');
-                return new value_or_promise_1.ValueOrPromise(() => importFn(moduleName))
+                return new ValueOrPromise(() => importFn(moduleName))
                     .then(module => (fetchFnName ? module[fetchFnName] : module))
                     .resolve();
             }
@@ -430,10 +426,10 @@ class UrlLoader {
             }
         }
         if (importFn === asyncImport) {
-            return defaultAsyncFetch_js_1.defaultAsyncFetch;
+            return defaultAsyncFetch;
         }
         else {
-            return defaultSyncFetch_js_1.defaultSyncFetch;
+            return defaultSyncFetch;
         }
     }
     getDefaultMethodFromOptions(method, defaultMethod) {
@@ -445,12 +441,12 @@ class UrlLoader {
     getWebSocketImpl(importFn, options) {
         if (typeof (options === null || options === void 0 ? void 0 : options.webSocketImpl) === 'string') {
             const [moduleName, webSocketImplName] = options.webSocketImpl.split('#');
-            return new value_or_promise_1.ValueOrPromise(() => importFn(moduleName))
+            return new ValueOrPromise(() => importFn(moduleName))
                 .then(importedModule => (webSocketImplName ? importedModule[webSocketImplName] : importedModule))
                 .resolve();
         }
         else {
-            const websocketImpl = (options === null || options === void 0 ? void 0 : options.webSocketImpl) || isomorphic_ws_1.default;
+            const websocketImpl = (options === null || options === void 0 ? void 0 : options.webSocketImpl) || WebSocket;
             return websocketImpl;
         }
     }
@@ -467,7 +463,7 @@ class UrlLoader {
             return this.buildHTTPExecutor(subscriptionsEndpoint, fetch, options);
         }
         else {
-            const webSocketImpl$ = new value_or_promise_1.ValueOrPromise(() => this.getWebSocketImpl(importFn, options));
+            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);
@@ -480,7 +476,7 @@ class UrlLoader {
         }
     }
     getExecutor(endpoint, importFn, options) {
-        const fetch$ = new value_or_promise_1.ValueOrPromise(() => this.getFetch(options === null || options === void 0 ? void 0 : options.customFetch, importFn));
+        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);
         });
@@ -491,9 +487,9 @@ class UrlLoader {
             });
             // eslint-disable-next-line no-inner-declarations
             function getExecutorByRequest(request) {
-                const operationAst = (0, utils_1.getOperationASTFromRequest)(request);
+                const operationAst = getOperationASTFromRequest(request);
                 if (operationAst.operation === 'subscription' ||
-                    (0, graphql_live_query_1.isLiveQueryOperationDefinitionNode)(operationAst, request.variables)) {
+                    isLiveQueryOperationDefinitionNode(operationAst, request.variables)) {
                     return subscriptionExecutor$;
                 }
                 else {
@@ -516,12 +512,12 @@ class UrlLoader {
     }
     handleSDL(pointer, fetch, options) {
         const defaultMethod = this.getDefaultMethodFromOptions(options === null || options === void 0 ? void 0 : options.method, 'GET');
-        return new value_or_promise_1.ValueOrPromise(() => fetch(pointer, {
+        return new ValueOrPromise(() => fetch(pointer, {
             method: defaultMethod,
             headers: options.headers,
         }))
             .then(response => response.text())
-            .then(schemaString => (0, utils_1.parseGraphQLSDL)(pointer, schemaString, options))
+            .then(schemaString => parseGraphQLSDL(pointer, schemaString, options))
             .resolve();
     }
     async load(pointer, options) {
@@ -541,14 +537,14 @@ class UrlLoader {
             source.schema =
                 source.schema ||
                     (source.document
-                        ? (0, graphql_1.buildASTSchema)(source.document, options)
+                        ? buildASTSchema(source.document, options)
                         : source.rawSDL
-                            ? (0, graphql_1.buildSchema)(source.rawSDL, options)
+                            ? buildSchema(source.rawSDL, options)
                             : undefined);
         }
         else {
             executor = this.getExecutorAsync(pointer, options);
-            source.schema = await (0, wrap_1.introspectSchema)(executor, {}, options);
+            source.schema = await introspectSchema(executor, {}, options);
         }
         if (!source.schema) {
             throw new Error(`Invalid introspected schema`);
@@ -557,7 +553,7 @@ class UrlLoader {
             executor = this.getExecutorAsync(options.endpoint, options);
         }
         if (executor) {
-            source.schema = (0, wrap_1.wrapSchema)({
+            source.schema = wrapSchema({
                 schema: source.schema,
                 executor,
                 batch: options === null || options === void 0 ? void 0 : options.batch,
@@ -582,14 +578,14 @@ class UrlLoader {
             source.schema =
                 source.schema ||
                     (source.document
-                        ? (0, graphql_1.buildASTSchema)(source.document, options)
+                        ? buildASTSchema(source.document, options)
                         : source.rawSDL
-                            ? (0, graphql_1.buildSchema)(source.rawSDL, options)
+                            ? buildSchema(source.rawSDL, options)
                             : undefined);
         }
         else {
             executor = this.getExecutorSync(pointer, options);
-            source.schema = (0, wrap_1.introspectSchema)(executor, {}, options);
+            source.schema = introspectSchema(executor, {}, options);
         }
         if (!source.schema) {
             throw new Error(`Invalid introspected schema`);
@@ -598,7 +594,7 @@ class UrlLoader {
             executor = this.getExecutorSync(options.endpoint, options);
         }
         if (executor) {
-            source.schema = (0, wrap_1.wrapSchema)({
+            source.schema = wrapSchema({
                 schema: source.schema,
                 executor,
             });
@@ -606,7 +602,6 @@ class UrlLoader {
         return [source];
     }
 }
-exports.UrlLoader = UrlLoader;
 function switchProtocols(pointer, protocolMap) {
     return Object.entries(protocolMap).reduce((prev, [source, target]) => prev.replace(`${source}://`, `${target}://`).replace(`${source}:\\`, `${target}:\\`), pointer);
 }

package/{cjs → esm}/utils.js

@@ -1,19 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LEGACY_WS = exports.isPromiseLike = exports.isGraphQLUpload = exports.isBlob = void 0;
-function isBlob(obj) {
+export function isBlob(obj) {
     return typeof obj.arrayBuffer === 'function';
 }
-exports.isBlob = isBlob;
-function isGraphQLUpload(upload) {
+export function isGraphQLUpload(upload) {
     return typeof upload.createReadStream === 'function';
 }
-exports.isGraphQLUpload = isGraphQLUpload;
-function isPromiseLike(obj) {
+export function isPromiseLike(obj) {
     return typeof obj.then === 'function';
 }
-exports.isPromiseLike = isPromiseLike;
-var LEGACY_WS;
+export var LEGACY_WS;
 (function (LEGACY_WS) {
     LEGACY_WS["CONNECTION_INIT"] = "connection_init";
     LEGACY_WS["CONNECTION_ACK"] = "connection_ack";
@@ -25,4 +19,4 @@ var LEGACY_WS;
     LEGACY_WS["DATA"] = "data";
     LEGACY_WS["ERROR"] = "error";
     LEGACY_WS["COMPLETE"] = "complete";
-})(LEGACY_WS = exports.LEGACY_WS || (exports.LEGACY_WS = {}));
+})(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.2",
   "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 {};

package/cjs/addCancelToResponseStream.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCancelToResponseStream = void 0;
-const utils_1 = require("@graphql-tools/utils");
-function addCancelToResponseStream(resultStream, controller) {
-    return (0, utils_1.withCancel)(resultStream, () => {
-        if (!controller.signal.aborted) {
-            controller.abort();
-        }
-    });
-}
-exports.addCancelToResponseStream = addCancelToResponseStream;

package/cjs/defaultAsyncFetch.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultAsyncFetch = void 0;
-const fetch_1 = require("@whatwg-node/fetch");
-const defaultAsyncFetch = async (input, init) => {
-    return (0, fetch_1.fetch)(input, init);
-};
-exports.defaultAsyncFetch = defaultAsyncFetch;

package/cjs/defaultSyncFetch.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultSyncFetch = void 0;
-const tslib_1 = require("tslib");
-const sync_fetch_1 = tslib_1.__importDefault(require("sync-fetch"));
-const defaultSyncFetch = (input, init) => {
-    if (typeof input === 'string') {
-        init === null || init === void 0 ? true : delete init.signal;
-    }
-    else {
-        delete input.signal;
-    }
-    return (0, sync_fetch_1.default)(input, init);
-};
-exports.defaultSyncFetch = defaultSyncFetch;

package/cjs/event-stream/handleEventStreamResponse.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleEventStreamResponse = void 0;
-const utils_1 = require("@graphql-tools/utils");
-const handleReadable_js_1 = require("./handleReadable.js");
-const handleReadableStream_js_1 = require("./handleReadableStream.js");
-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 ((0, utils_1.isAsyncIterable)(body)) {
-            return (0, handleReadable_js_1.handleReadable)(body);
-        }
-        return (0, handleReadableStream_js_1.handleReadableStream)(body);
-    }
-    throw new Error('Response body is expected to be a readable stream but got; ' + (0, utils_1.inspect)(body));
-}
-exports.handleEventStreamResponse = handleEventStreamResponse;