@graphql-tools/url-loader 7.2.1-alpha-0dcd17c0.0 → 7.2.1

package/addCancelToResponseStream.d.ts

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

package/defaultAsyncFetch.d.ts

@@ -0,0 +1,3 @@
+import { fetch as crossFetch } from 'cross-fetch';
+export declare type AsyncFetchFn = typeof crossFetch;
+export declare const defaultAsyncFetch: AsyncFetchFn;

package/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/event-stream/handleEventStreamResponse.d.ts

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

package/event-stream/handlePart.d.ts

@@ -0,0 +1,2 @@
+import { ExecutionResult } from 'graphql';
+export declare function handlePart(part: string): false | ExecutionResult;

package/event-stream/handleReadable.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import type { Readable } from 'stream';
+export declare function handleReadable(readable: Readable): AsyncGenerator<import("graphql").ExecutionResult<{
+    [key: string]: any;
+}, {
+    [key: string]: any;
+}>, void, unknown>;

package/event-stream/handleReadableStream.d.ts

@@ -0,0 +1 @@
+export declare function handleReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<ReadableStreamDefaultReadValueResult<Uint8Array>, void, unknown>;

package/handleMultipartMixedResponse.d.ts

@@ -0,0 +1,6 @@
+import { ExecutionResult } from 'graphql';
+export declare function handleMultipartMixedResponse(response: Response): Promise<AsyncIterableIterator<ExecutionResult<{
+    [key: string]: any;
+}, {
+    [key: string]: any;
+}> | undefined>>;

package/index.d.ts

@@ -6,14 +6,9 @@ import { ClientOptions } from 'graphql-ws';
 import { ClientOptions as GraphQLSSEClientOptions } from 'graphql-sse';
 import WebSocket from 'isomorphic-ws';
 import FormData from 'form-data';
-import { FetchEventSourceInit } from '@ardatan/fetch-event-source';
 import { ConnectionParamsOptions } from 'subscriptions-transport-ws';
-export declare type AsyncFetchFn = typeof import('cross-fetch').fetch;
-export declare type SyncFetchFn = (input: RequestInfo, init?: RequestInit) => SyncResponse;
-export declare type SyncResponse = Omit<Response, 'json' | 'text'> & {
-    json: () => any;
-    text: () => string;
-};
+import { AsyncFetchFn } from './defaultAsyncFetch';
+import { SyncFetchFn } from './defaultSyncFetch';
 export declare type FetchFn = AsyncFetchFn | SyncFetchFn;
 export declare type AsyncImportFn = (moduleName: string) => PromiseLike<any>;
 export declare type SyncImportFn = (moduleName: string) => any;
@@ -66,10 +61,6 @@ export interface LoadFromUrlOptions extends BaseLoaderOptions, Partial<Introspec
      * Use multipart for POST requests
      */
     multipart?: boolean;
-    /**
-     * Additional options to pass to the constructor of the underlying EventSource instance.
-     */
-    eventSourceOptions?: FetchEventSourceInit;
     /**
      * Handle URL as schema SDL
      */
@@ -123,9 +114,8 @@ export declare class UrlLoader implements Loader<LoadFromUrlOptions> {
     buildHTTPExecutor(endpoint: string, fetch: AsyncFetchFn, options?: LoadFromUrlOptions): AsyncExecutor<any, ExecutionExtensions>;
     buildWSExecutor(subscriptionsEndpoint: string, webSocketImpl: typeof WebSocket, connectionParams?: ClientOptions['connectionParams']): AsyncExecutor;
     buildWSLegacyExecutor(subscriptionsEndpoint: string, webSocketImpl: typeof WebSocket, connectionParams?: ConnectionParamsOptions): AsyncExecutor;
-    buildSSEExecutor(endpoint: string, fetch: AsyncFetchFn, options?: Omit<LoadFromUrlOptions, 'subscriptionEndpoint'>): AsyncExecutor<any, ExecutionExtensions>;
     buildGraphQLSSEExecutor(endpoint: string, fetch: AsyncFetchFn, options?: Omit<LoadFromUrlOptions, 'subscriptionEndpoint'>): AsyncExecutor;
-    getFetch(customFetch: LoadFromUrlOptions['customFetch'], importFn: AsyncImportFn): PromiseLike<AsyncFetchFn>;
+    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>;

package/index.js

@@ -26,25 +26,31 @@ function _interopNamespace(e) {
 const graphql = require('graphql');
 const utils = require('@graphql-tools/utils');
 const validUrl = require('valid-url');
-const crossFetch = require('cross-fetch');
 const wrap = require('@graphql-tools/wrap');
 const graphqlWs = require('graphql-ws');
 const graphqlSse = require('graphql-sse');
 const WebSocket = _interopDefault(require('isomorphic-ws'));
-const syncFetchImported = _interopDefault(require('sync-fetch'));
 const isPromise = _interopDefault(require('is-promise'));
 const extractFiles = require('extract-files');
 const FormData = _interopDefault(require('form-data'));
-const fetchEventSource = require('@ardatan/fetch-event-source');
 const subscriptionsTransportWs = require('subscriptions-transport-ws');
 const AbortController = _interopDefault(require('abort-controller'));
-const meros = require('meros');
-const _ = _interopDefault(require('lodash'));
 const valueOrPromise = require('value-or-promise');
 const graphqlLiveQuery = require('@n1ru4l/graphql-live-query');
+const crossFetch = require('cross-fetch');
+const syncFetchImported = _interopDefault(require('sync-fetch'));
+const node = require('meros/node');
+const browser = require('meros/browser');
+const _ = _interopDefault(require('lodash'));
 
-/* eslint-disable no-case-declarations */
-const syncFetch = (input, init) => {
+const defaultAsyncFetch = async (input, init) => {
+    if (typeof fetch !== 'undefined') {
+        return fetch(input, init);
+    }
+    return crossFetch.fetch(input, init);
+};
+
+const defaultSyncFetch = (input, init) => {
     if (typeof input === 'string') {
         init === null || init === void 0 ? true : delete init.signal;
     }
@@ -53,6 +59,124 @@ const syncFetch = (input, init) => {
     }
     return syncFetchImported(input, init);
 };
+
+/* eslint-disable */
+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 node.meros(body));
+    }
+    else {
+        // Nothing is needed for regular `Response`.
+        asyncIterator = (await browser.meros(response));
+    }
+    const executionResult = {};
+    return utils.mapAsyncIterator(asyncIterator, (part) => {
+        if (part.json) {
+            const chunk = part.body;
+            if (chunk.path) {
+                if (chunk.data) {
+                    const path = ['data'];
+                    _.set(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;
+        }
+    });
+}
+
+function handlePart(part) {
+    const eventStr = part.split('event: ')[1];
+    const dataStr = part.split('data: ')[1];
+    const data = JSON.parse(dataStr);
+    if (data.payload && eventStr) {
+        if (eventStr === 'complete') {
+            return false;
+        }
+        else {
+            return data.payload;
+        }
+    }
+    return data;
+}
+
+async function* handleReadable(readable) {
+    outer: for await (const chunk of readable) {
+        const chunkStr = chunk.toString();
+        for (const part of chunkStr.split('\n\n')) {
+            if (part) {
+                const result = handlePart(part);
+                if (result === false) {
+                    break outer;
+                }
+                yield result;
+            }
+        }
+    }
+}
+
+/* eslint-disable no-labels */
+async function* handleReadableStream(stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    try {
+        let result;
+        outer: while (!(result = await reader.read()).done) {
+            const chunk = decoder.decode(result.value);
+            for (const part of chunk.toString().split('\n\n')) {
+                if (part) {
+                    const executionResult = handlePart(part);
+                    if (executionResult === false) {
+                        break outer;
+                    }
+                    yield result;
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+
+/* eslint-disable */
+async function handleEventStreamResponse(response) {
+    const body = await response.body;
+    if (body) {
+        if ('pipe' in body) {
+            return handleReadable(body);
+        }
+        return handleReadableStream(body);
+    }
+    throw new Error('Body is null???');
+}
+
+function addCancelToResponseStream(resultStream, controller) {
+    return utils.withCancel(resultStream, () => controller.abort());
+}
+
+/* eslint-disable no-case-declarations */
 const asyncImport = (moduleName) => new Promise(function (resolve) { resolve(_interopNamespace(require(moduleName))); });
 const syncImport = (moduleName) => require(moduleName);
 (function (SubscriptionProtocol) {
@@ -218,7 +342,7 @@ class UrlLoader {
                                     extensions,
                                 }),
                                 headers: {
-                                    accept: 'application/json, multipart/mixed',
+                                    accept: 'application/json, multipart/mixed, text/event-stream',
                                     'content-type': 'application/json',
                                     ...headers,
                                 },
@@ -228,41 +352,12 @@ class UrlLoader {
                 }
             })
                 .then((fetchResult) => {
-                const response = {};
-                const contentType = fetchResult.headers.get
-                    ? fetchResult.headers.get('content-type')
-                    : fetchResult['content-type'];
-                if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('multipart/mixed')) {
-                    return meros.meros(fetchResult).then(maybeStream => {
-                        if (utils.isAsyncIterable(maybeStream)) {
-                            return utils.withCancel(utils.mapAsyncIterator(maybeStream, part => {
-                                if (part.json) {
-                                    const chunk = part.body;
-                                    if (chunk.path) {
-                                        if (chunk.data) {
-                                            const path = ['data'];
-                                            _.merge(response, _.set({}, path.concat(chunk.path), chunk.data));
-                                        }
-                                        if (chunk.errors) {
-                                            response.errors = (response.errors || []).concat(chunk.errors);
-                                        }
-                                    }
-                                    else {
-                                        if (chunk.data) {
-                                            response.data = chunk.data;
-                                        }
-                                        if (chunk.errors) {
-                                            response.errors = chunk.errors;
-                                        }
-                                    }
-                                    return response;
-                                }
-                            }), () => controller.abort());
-                        }
-                        else {
-                            return maybeStream.json();
-                        }
-                    });
+                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.json();
             })
@@ -315,52 +410,6 @@ class UrlLoader {
             }));
         };
     }
-    buildSSEExecutor(endpoint, fetch, options) {
-        return async ({ document, variables, extensions, operationName }) => {
-            const controller = new AbortController();
-            const query = graphql.print(document);
-            const finalUrl = this.prepareGETUrl({ baseUrl: endpoint, query, variables, operationName, extensions });
-            return utils.observableToAsyncIterable({
-                subscribe: observer => {
-                    const headers = Object.assign({}, (options === null || options === void 0 ? void 0 : options.headers) || {}, (extensions === null || extensions === void 0 ? void 0 : extensions.headers) || {});
-                    fetchEventSource.fetchEventSource(finalUrl, {
-                        credentials: 'include',
-                        headers,
-                        method: 'GET',
-                        onerror: error => {
-                            observer.error(error);
-                        },
-                        onmessage: event => {
-                            observer.next(JSON.parse(event.data || '{}'));
-                        },
-                        onopen: async (response) => {
-                            const contentType = response.headers.get('content-type');
-                            if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith('text/event-stream'))) {
-                                let error;
-                                try {
-                                    const { errors } = await response.json();
-                                    error = errors[0];
-                                }
-                                catch (error) {
-                                    // Failed to parse body
-                                }
-                                if (error) {
-                                    throw error;
-                                }
-                                throw new Error(`Expected content-type to be ${'text/event-stream'} but got "${contentType}".`);
-                            }
-                        },
-                        fetch,
-                        signal: controller.signal,
-                        ...((options === null || options === void 0 ? void 0 : options.eventSourceOptions) || {}),
-                    });
-                    return {
-                        unsubscribe: () => controller.abort(),
-                    };
-                },
-            });
-        };
-    }
     buildGraphQLSSEExecutor(endpoint, fetch, options = {}) {
         const { headers } = options;
         const client = graphqlSse.createClient({
@@ -394,18 +443,15 @@ class UrlLoader {
                     .then(module => (fetchFnName ? module[fetchFnName] : module))
                     .resolve();
             }
-            else {
+            else if (typeof customFetch === 'function') {
                 return customFetch;
             }
         }
         if (importFn === asyncImport) {
-            if (typeof fetch === 'undefined') {
-                return crossFetch.fetch;
-            }
-            return fetch;
+            return defaultAsyncFetch;
         }
         else {
-            return syncFetch;
+            return defaultSyncFetch;
         }
     }
     getDefaultMethodFromOptions(method, defaultMethod) {
@@ -428,7 +474,10 @@ class UrlLoader {
     }
     async buildSubscriptionExecutor(subscriptionsEndpoint, fetch, options) {
         if ((options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) === exports.SubscriptionProtocol.SSE) {
-            return this.buildSSEExecutor(subscriptionsEndpoint, fetch, options);
+            return this.buildHTTPExecutor(subscriptionsEndpoint, fetch, {
+                ...options,
+                method: 'GET',
+            });
         }
         else if ((options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) === exports.SubscriptionProtocol.GRAPHQL_SSE) {
             if (!(options === null || options === void 0 ? void 0 : options.subscriptionsEndpoint)) {
@@ -459,7 +508,7 @@ class UrlLoader {
             if (!operationAst) {
                 throw new Error(`No valid operations found: ${params.operationName || ''}`);
             }
-            if (params.operationType === 'subscription' ||
+            if (operationAst.operation === 'subscription' ||
                 graphqlLiveQuery.isLiveQueryOperationDefinitionNode(operationAst, params.variables)) {
                 return subscriptionExecutor(params);
             }

package/index.mjs

@@ -1,25 +1,31 @@
 import { print, getOperationAST, buildASTSchema, buildSchema } from 'graphql';
-import { isAsyncIterable, observableToAsyncIterable, parseGraphQLSDL, withCancel, mapAsyncIterator } from '@graphql-tools/utils';
+import { mapAsyncIterator, withCancel, isAsyncIterable, observableToAsyncIterable, parseGraphQLSDL } from '@graphql-tools/utils';
 import { isWebUri } from 'valid-url';
-import { fetch as fetch$1 } from 'cross-fetch';
 import { introspectSchema, wrapSchema } from '@graphql-tools/wrap';
 import { createClient } from 'graphql-ws';
 import { createClient as createClient$1 } from 'graphql-sse';
 import WebSocket from 'isomorphic-ws';
-import syncFetchImported from 'sync-fetch';
 import isPromise from 'is-promise';
 import { extractFiles, isExtractableFile } from 'extract-files';
 import FormData from 'form-data';
-import { fetchEventSource } from '@ardatan/fetch-event-source';
 import { SubscriptionClient } from 'subscriptions-transport-ws';
 import AbortController from 'abort-controller';
-import { meros } from 'meros';
-import _ from 'lodash';
 import { ValueOrPromise } from 'value-or-promise';
 import { isLiveQueryOperationDefinitionNode } from '@n1ru4l/graphql-live-query';
+import { fetch as fetch$1 } from 'cross-fetch';
+import syncFetchImported from 'sync-fetch';
+import { meros } from 'meros/node';
+import { meros as meros$1 } from 'meros/browser';
+import _ from 'lodash';
 
-/* eslint-disable no-case-declarations */
-const syncFetch = (input, init) => {
+const defaultAsyncFetch = async (input, init) => {
+    if (typeof fetch !== 'undefined') {
+        return fetch(input, init);
+    }
+    return fetch$1(input, init);
+};
+
+const defaultSyncFetch = (input, init) => {
     if (typeof input === 'string') {
         init === null || init === void 0 ? true : delete init.signal;
     }
@@ -28,6 +34,124 @@ const syncFetch = (input, init) => {
     }
     return syncFetchImported(input, init);
 };
+
+/* eslint-disable */
+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'];
+                    _.set(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;
+        }
+    });
+}
+
+function handlePart(part) {
+    const eventStr = part.split('event: ')[1];
+    const dataStr = part.split('data: ')[1];
+    const data = JSON.parse(dataStr);
+    if (data.payload && eventStr) {
+        if (eventStr === 'complete') {
+            return false;
+        }
+        else {
+            return data.payload;
+        }
+    }
+    return data;
+}
+
+async function* handleReadable(readable) {
+    outer: for await (const chunk of readable) {
+        const chunkStr = chunk.toString();
+        for (const part of chunkStr.split('\n\n')) {
+            if (part) {
+                const result = handlePart(part);
+                if (result === false) {
+                    break outer;
+                }
+                yield result;
+            }
+        }
+    }
+}
+
+/* eslint-disable no-labels */
+async function* handleReadableStream(stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    try {
+        let result;
+        outer: while (!(result = await reader.read()).done) {
+            const chunk = decoder.decode(result.value);
+            for (const part of chunk.toString().split('\n\n')) {
+                if (part) {
+                    const executionResult = handlePart(part);
+                    if (executionResult === false) {
+                        break outer;
+                    }
+                    yield result;
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+
+/* eslint-disable */
+async function handleEventStreamResponse(response) {
+    const body = await response.body;
+    if (body) {
+        if ('pipe' in body) {
+            return handleReadable(body);
+        }
+        return handleReadableStream(body);
+    }
+    throw new Error('Body is null???');
+}
+
+function addCancelToResponseStream(resultStream, controller) {
+    return withCancel(resultStream, () => controller.abort());
+}
+
+/* eslint-disable no-case-declarations */
 const asyncImport = (moduleName) => import(moduleName);
 const syncImport = (moduleName) => require(moduleName);
 var SubscriptionProtocol;
@@ -194,7 +318,7 @@ class UrlLoader {
                                     extensions,
                                 }),
                                 headers: {
-                                    accept: 'application/json, multipart/mixed',
+                                    accept: 'application/json, multipart/mixed, text/event-stream',
                                     'content-type': 'application/json',
                                     ...headers,
                                 },
@@ -204,41 +328,12 @@ class UrlLoader {
                 }
             })
                 .then((fetchResult) => {
-                const response = {};
-                const contentType = fetchResult.headers.get
-                    ? fetchResult.headers.get('content-type')
-                    : fetchResult['content-type'];
-                if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('multipart/mixed')) {
-                    return meros(fetchResult).then(maybeStream => {
-                        if (isAsyncIterable(maybeStream)) {
-                            return withCancel(mapAsyncIterator(maybeStream, part => {
-                                if (part.json) {
-                                    const chunk = part.body;
-                                    if (chunk.path) {
-                                        if (chunk.data) {
-                                            const path = ['data'];
-                                            _.merge(response, _.set({}, path.concat(chunk.path), chunk.data));
-                                        }
-                                        if (chunk.errors) {
-                                            response.errors = (response.errors || []).concat(chunk.errors);
-                                        }
-                                    }
-                                    else {
-                                        if (chunk.data) {
-                                            response.data = chunk.data;
-                                        }
-                                        if (chunk.errors) {
-                                            response.errors = chunk.errors;
-                                        }
-                                    }
-                                    return response;
-                                }
-                            }), () => controller.abort());
-                        }
-                        else {
-                            return maybeStream.json();
-                        }
-                    });
+                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.json();
             })
@@ -291,52 +386,6 @@ class UrlLoader {
             }));
         };
     }
-    buildSSEExecutor(endpoint, fetch, options) {
-        return async ({ document, variables, extensions, operationName }) => {
-            const controller = new AbortController();
-            const query = print(document);
-            const finalUrl = this.prepareGETUrl({ baseUrl: endpoint, query, variables, operationName, extensions });
-            return observableToAsyncIterable({
-                subscribe: observer => {
-                    const headers = Object.assign({}, (options === null || options === void 0 ? void 0 : options.headers) || {}, (extensions === null || extensions === void 0 ? void 0 : extensions.headers) || {});
-                    fetchEventSource(finalUrl, {
-                        credentials: 'include',
-                        headers,
-                        method: 'GET',
-                        onerror: error => {
-                            observer.error(error);
-                        },
-                        onmessage: event => {
-                            observer.next(JSON.parse(event.data || '{}'));
-                        },
-                        onopen: async (response) => {
-                            const contentType = response.headers.get('content-type');
-                            if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith('text/event-stream'))) {
-                                let error;
-                                try {
-                                    const { errors } = await response.json();
-                                    error = errors[0];
-                                }
-                                catch (error) {
-                                    // Failed to parse body
-                                }
-                                if (error) {
-                                    throw error;
-                                }
-                                throw new Error(`Expected content-type to be ${'text/event-stream'} but got "${contentType}".`);
-                            }
-                        },
-                        fetch,
-                        signal: controller.signal,
-                        ...((options === null || options === void 0 ? void 0 : options.eventSourceOptions) || {}),
-                    });
-                    return {
-                        unsubscribe: () => controller.abort(),
-                    };
-                },
-            });
-        };
-    }
     buildGraphQLSSEExecutor(endpoint, fetch, options = {}) {
         const { headers } = options;
         const client = createClient$1({
@@ -370,18 +419,15 @@ class UrlLoader {
                     .then(module => (fetchFnName ? module[fetchFnName] : module))
                     .resolve();
             }
-            else {
+            else if (typeof customFetch === 'function') {
                 return customFetch;
             }
         }
         if (importFn === asyncImport) {
-            if (typeof fetch === 'undefined') {
-                return fetch$1;
-            }
-            return fetch;
+            return defaultAsyncFetch;
         }
         else {
-            return syncFetch;
+            return defaultSyncFetch;
         }
     }
     getDefaultMethodFromOptions(method, defaultMethod) {
@@ -404,7 +450,10 @@ class UrlLoader {
     }
     async buildSubscriptionExecutor(subscriptionsEndpoint, fetch, options) {
         if ((options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) === SubscriptionProtocol.SSE) {
-            return this.buildSSEExecutor(subscriptionsEndpoint, fetch, options);
+            return this.buildHTTPExecutor(subscriptionsEndpoint, fetch, {
+                ...options,
+                method: 'GET',
+            });
         }
         else if ((options === null || options === void 0 ? void 0 : options.subscriptionsProtocol) === SubscriptionProtocol.GRAPHQL_SSE) {
             if (!(options === null || options === void 0 ? void 0 : options.subscriptionsEndpoint)) {
@@ -435,7 +484,7 @@ class UrlLoader {
             if (!operationAst) {
                 throw new Error(`No valid operations found: ${params.operationName || ''}`);
             }
-            if (params.operationType === 'subscription' ||
+            if (operationAst.operation === 'subscription' ||
                 isLiveQueryOperationDefinitionNode(operationAst, params.variables)) {
                 return subscriptionExecutor(params);
             }

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@graphql-tools/url-loader",
-  "version": "7.2.1-alpha-0dcd17c0.0",
+  "version": "7.2.1",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@ardatan/fetch-event-source": "2.0.2",
-    "@graphql-tools/delegate": "8.3.0-alpha-0dcd17c0.0",
-    "@graphql-tools/utils": "8.4.0-alpha-0dcd17c0.0",
-    "@graphql-tools/wrap": "8.2.0-alpha-0dcd17c0.0",
+    "@graphql-tools/delegate": "^8.2.0",
+    "@graphql-tools/utils": "^8.2.0",
+    "@graphql-tools/wrap": "^8.1.0",
     "@n1ru4l/graphql-live-query": "0.8.1",
     "@types/websocket": "1.0.4",
     "@types/ws": "^8.0.0",