@graphql-tools/url-loader 7.13.3 → 7.13.4-alpha-b9e4a92b.0

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@graphql-tools/url-loader",
-  "version": "7.13.3",
+  "version": "7.13.4-alpha-b9e4a92b.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "8.8.1",
-    "@graphql-tools/utils": "8.9.0",
-    "@graphql-tools/wrap": "8.5.1",
+    "@graphql-tools/delegate": "8.8.2-alpha-b9e4a92b.0",
+    "@graphql-tools/utils": "8.9.1-alpha-b9e4a92b.0",
+    "@graphql-tools/wrap": "8.5.2-alpha-b9e4a92b.0",
     "@ardatan/sync-fetch": "0.0.1",
     "@n1ru4l/graphql-live-query": "^0.10.0",
     "@types/ws": "^8.0.0",
@@ -40,7 +40,7 @@
   "exports": {
     ".": {
       "require": {
-        "types": "./typings/index.d.ts",
+        "types": "./typings/index.d.cts",
         "default": "./cjs/index.js"
       },
       "import": {
@@ -54,7 +54,7 @@
     },
     "./*": {
       "require": {
-        "types": "./typings/*.d.ts",
+        "types": "./typings/*.d.cts",
         "default": "./cjs/*.js"
       },
       "import": {

package/typings/addCancelToResponseStream.d.cts

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

package/typings/defaultAsyncFetch.d.cts

@@ -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.cts

@@ -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/handleAsyncIterable.d.cts

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

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

@@ -0,0 +1,3 @@
+import { ExecutionResult } from 'graphql';
+export declare function isReadableStream(value: any): value is ReadableStream;
+export declare function handleEventStreamResponse(response: Response): Promise<AsyncIterable<ExecutionResult>>;

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

@@ -0,0 +1,2 @@
+import { ExecutionResult } from 'graphql';
+export declare function handleReadableStream(readableStream: ReadableStream<Uint8Array>): AsyncIterableIterator<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;

package/typings/handleMultipartMixedResponse.d.cts

@@ -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.cts

@@ -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.cjs';
+import { SyncFetchFn } from './defaultSyncFetch.cjs';
+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.cts

@@ -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 {};