@vladimirdev635/gql-client 0.0.61 → 0.0.63

package/executor.d.ts

@@ -0,0 +1,7 @@
+import { ClientConfig, ExecuteResult, IExecutor, OperationResult, OperationVariables, RequestContext, SubOpAsyncIterable, SubscriptionOperation, SyncOperation } from './types/index.js';
+export declare class Executor<TClientContext, TRequestContext extends RequestContext> implements IExecutor<TRequestContext> {
+    private readonly config;
+    constructor(config: ClientConfig<TClientContext, TRequestContext>);
+    executeSync<T extends SyncOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): Promise<ExecuteResult<OperationResult<T>>>;
+    executeSubscription<T extends SubscriptionOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext, controller: AbortController): Promise<ExecuteResult<SubOpAsyncIterable<OperationResult<T>>>>;
+}

package/executor.js

@@ -0,0 +1,119 @@
+export class Executor {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async executeSync(operation, variables, requestContext) {
+        for (const middleware of this.config.middlewares.beforeSerialization) {
+            [operation, variables] = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables
+            });
+        }
+        let init = await this.config.serializer.serializeRequest({
+            clientContext: this.config.context,
+            requestContext,
+            operation,
+            variables
+        });
+        for (const middleware of this.config.middlewares.afterSerialization.sync) {
+            init = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables,
+                init
+            });
+        }
+        let response = await this.config.fetcher(init);
+        for (const middleware of this.config.middlewares.beforeParsing.sync) {
+            response = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables,
+                init,
+                response
+            });
+        }
+        let result = await this.config.parser.parseBodySync({
+            clientContext: this.config.context,
+            requestContext,
+            operation,
+            response
+        });
+        for (const middleware of this.config.middlewares.afterParsing.sync) {
+            result = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables,
+                init,
+                response,
+                result
+            });
+        }
+        return { result, response };
+    }
+    async executeSubscription(operation, variables, requestContext, controller) {
+        for (const middleware of this.config.middlewares.beforeSerialization) {
+            [operation, variables] = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables
+            });
+        }
+        let init = await this.config.serializer.serializeRequest({
+            clientContext: this.config.context,
+            requestContext,
+            operation,
+            variables
+        });
+        for (const middleware of this.config.middlewares.afterSerialization.subscription) {
+            init = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables,
+                init,
+                controller
+            });
+        }
+        init.signal = controller.signal;
+        let response = await this.config.fetcher(init);
+        for (const middleware of this.config.middlewares.beforeParsing.subscription) {
+            response = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables,
+                init,
+                response,
+                controller
+            });
+        }
+        let result = await this.config.parser.parseBodySubscription({
+            clientContext: this.config.context,
+            requestContext,
+            operation,
+            response,
+            controller
+        });
+        for (const middleware of this.config.middlewares.afterParsing.subscription) {
+            result = await middleware({
+                clientContext: this.config.context,
+                requestContext,
+                operation,
+                variables,
+                init,
+                response,
+                result,
+                controller
+            });
+        }
+        return { result, response };
+    }
+}

package/index.d.ts

@@ -1,4 +1,4 @@
-export { createParser, type CreateParserOptions, } from './parser.js';
-export { createSerializer, createJSONSerializer, createMultipartSerializer, hasBlobValue } from './serializers/index.js';
-export { execute, bindConfigToExecute, type Executor, type ExecuteResult } from './execute.js';
-export type { Operation, SyncOperation, SubscriptionOperation, SubOpAsyncIterable, RequestContext, ClientParser, ClientSerializer, ClientConfig, ClientMiddlewaresConfig, BeforeSerializationMiddleware, AfterSerializationMiddleware, BeforeParsingMiddleware, AfterParsingMiddleware, OpResultBasedOnOp, OperationVariables, OperationResult } from './types/index.js';
+export * as parsers from './parsers/index.js';
+export * as serializers from './serializers/index.js';
+export type * as types from './types/index.js';
+export { Executor } from './executor.js';

package/index.js

@@ -1,3 +1,3 @@
-export { createParser, } from './parser.js';
-export { createSerializer, createJSONSerializer, createMultipartSerializer, hasBlobValue } from './serializers/index.js';
-export { execute, bindConfigToExecute } from './execute.js';
+export * as parsers from './parsers/index.js';
+export * as serializers from './serializers/index.js';
+export { Executor } from './executor.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vladimirdev635/gql-client",
-    "version": "0.0.61",
+    "version": "0.0.63",
     "type": "module",
     "main": "./index.js",
     "types": "./index.d.ts",

package/parsers/index.d.ts

@@ -0,0 +1 @@
+export { createParser, type CreateParserOptions } from './parser.js';

package/parsers/index.js

@@ -0,0 +1 @@
+export { createParser } from './parser.js';

package/parsers/parseBodySubscription.d.ts

@@ -0,0 +1,3 @@
+import { RequestContext, SubscriptionOperation } from '@/types/base.js';
+import { ClientParserParseBodySubscriptionOptions } from '@/types/parser.js';
+export declare function buildParseBodySubscriptionFunc<TClientContext, TRequestContext extends RequestContext>(): <T extends SubscriptionOperation<unknown, unknown>>(options: ClientParserParseBodySubscriptionOptions<TClientContext, TRequestContext, T>) => Promise<any>;

package/parsers/parseBodySubscription.js

@@ -0,0 +1,49 @@
+import assert from 'assert';
+export function buildParseBodySubscriptionFunc() {
+    return async (options
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) => {
+        if (options.response.status !== 200) {
+            throw new Error(await options.response.text());
+        }
+        assert(options.response.headers.get('content-type') ===
+            'text/event-stream');
+        const rStream = options.response.body;
+        assert(rStream !== null);
+        const reader = rStream.getReader();
+        const decoder = new TextDecoder();
+        let shouldClose = false;
+        let resolve;
+        const signal = new Promise(res => resolve = res);
+        const close = () => {
+            shouldClose = true;
+            resolve({ done: true, value: undefined });
+            options.controller.abort();
+        };
+        const stream = async function* () {
+            while (!shouldClose) {
+                const readResult = await Promise.race([
+                    reader.read(),
+                    signal
+                ]);
+                if (readResult.done)
+                    return;
+                const lines = decoder.decode(readResult.value)
+                    .split('\n');
+                for (const line of lines.filter(c => c !== '')) {
+                    if (shouldClose)
+                        break;
+                    const [name, value] = line.split(/:(.*)/s, 2);
+                    if (name !== 'data')
+                        continue;
+                    yield options.operation.resultSchema.parse(JSON.parse(value).data);
+                }
+            }
+        }();
+        return {
+            stream,
+            close,
+            [Symbol.dispose]: close
+        };
+    };
+}

package/{parser.d.ts → parsers/parser.d.ts}

@@ -1,5 +1,5 @@
-import { ClientParser, Operation, RequestContext, ClientParserParseBodyOptions } from './types/index.js';
+import { ClientParser, Operation, RequestContext, ClientParserParseBodySyncOptions } from '../types/index.js';
 export interface CreateParserOptions<TClientContext, TRequestContext extends RequestContext> {
-    onErrors: <T extends Operation<unknown, unknown>>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, T>, errors: any[]) => Promise<void> | void;
+    onErrors: <T extends Operation<unknown, unknown>>(options: ClientParserParseBodySyncOptions<TClientContext, TRequestContext, T>, errors: any[]) => Promise<void> | void;
 }
 export declare function createParser<TClientContext, TRequestContext extends RequestContext>(parserOptions?: CreateParserOptions<TClientContext, TRequestContext>): ClientParser<TClientContext, TRequestContext>;

package/parsers/parser.js

@@ -0,0 +1,20 @@
+import { buildParseBodySubscriptionFunc } from './parseBodySubscription.js';
+const defaultParserOptions = {
+    onErrors(_, errors) {
+        throw new Error(JSON.stringify(errors));
+    },
+};
+export function createParser(parserOptions = defaultParserOptions) {
+    return {
+        parseBodySync: async (options
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ) => {
+            const json = await options.response.json();
+            if (json.errors) {
+                await parserOptions.onErrors(options, json.errors);
+            }
+            return options.operation.resultSchema.parse(json.data);
+        },
+        parseBodySubscription: buildParseBodySubscriptionFunc()
+    };
+}

package/types/config.d.ts

@@ -1,5 +1,5 @@
 import { RequestContext } from './base.js';
-import { ClientMiddlewaresConfig } from './middlewares.js';
+import { ClientMiddlewaresConfig } from './middlewares/config.js';
 import { ClientParser } from './parser.js';
 import { ClientSerializer } from './serializer.js';
 export interface ClientConfig<TClientContext, TRequestContext extends RequestContext> {

package/types/iexecutor.d.ts

@@ -0,0 +1,10 @@
+import { OperationResult, OperationVariables, RequestContext, SubscriptionOperation, SyncOperation } from './base.js';
+import { SubOpAsyncIterable } from './parser.js';
+export interface ExecuteResult<TResult> {
+    result: TResult;
+    response: Response;
+}
+export interface IExecutor<TRequestContext extends RequestContext> {
+    executeSync<T extends SyncOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): Promise<ExecuteResult<OperationResult<T>>>;
+    executeSubscription<T extends SubscriptionOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext, controller: AbortController): Promise<ExecuteResult<SubOpAsyncIterable<OperationResult<T>>>>;
+}

package/types/index.d.ts

@@ -1,6 +1,7 @@
 export type { Operation, SyncOperation, SubscriptionOperation, RequestContext, OperationVariables, OperationResult } from './base.js';
-export type { BeforeSerializationMiddleware, AfterSerializationMiddleware, BeforeParsingMiddleware, AfterParsingMiddleware, ClientMiddlewaresConfig } from './middlewares.js';
-export type { ClientParser, ClientParserParseBodyOptions, SubOpAsyncIterable } from './parser.js';
+export * as middlewares from './middlewares/index.js';
+export type { ClientParser, ClientParserParseBodySyncOptions, ClientParserParseBodySubscriptionOptions, SubOpAsyncIterable } from './parser.js';
 export type { ClientSerializer } from './serializer.js';
 export type { ClientConfig } from './config.js';
 export type { OpResultBasedOnOp } from './utils.js';
+export type { IExecutor, ExecuteResult } from './iexecutor.js';

package/types/index.js

@@ -1 +1 @@
-export {};
+export * as middlewares from './middlewares/index.js';

package/types/middlewares/config.d.ts

@@ -0,0 +1,18 @@
+import { RequestContext } from '../base.js';
+import { AfterSerializationSubscriptionMiddleware, AfterSerializationSyncMiddleware, BeforeSerializationMiddleware } from './serialization.js';
+import { AfterParsingSubscriptionMiddleware, AfterParsingSyncMiddleware, BeforeParsingSubscriptionMiddleware, BeforeParsingSyncMiddleware } from './parsing.js';
+export interface ClientMiddlewaresConfig<TClientContext, TRequestContext extends RequestContext> {
+    beforeSerialization: BeforeSerializationMiddleware<TClientContext, TRequestContext>[];
+    afterSerialization: {
+        sync: AfterSerializationSyncMiddleware<TClientContext, TRequestContext>[];
+        subscription: AfterSerializationSubscriptionMiddleware<TClientContext, TRequestContext>[];
+    };
+    beforeParsing: {
+        sync: BeforeParsingSyncMiddleware<TClientContext, TRequestContext>[];
+        subscription: BeforeParsingSubscriptionMiddleware<TClientContext, TRequestContext>[];
+    };
+    afterParsing: {
+        sync: AfterParsingSyncMiddleware<TClientContext, TRequestContext>[];
+        subscription: AfterParsingSubscriptionMiddleware<TClientContext, TRequestContext>[];
+    };
+}

package/types/middlewares/config.js

@@ -0,0 +1 @@
+export {};

package/types/middlewares/index.d.ts

@@ -0,0 +1,3 @@
+export type { BeforeSerializationMiddleware, AfterSerializationSyncMiddleware, AfterSerializationSubscriptionMiddleware, } from './serialization.js';
+export type { BeforeParsingSyncMiddleware, BeforeParsingSubscriptionMiddleware, AfterParsingSyncMiddleware, AfterParsingSubscriptionMiddleware, } from './parsing.js';
+export type { ClientMiddlewaresConfig } from './config.js';

package/types/middlewares/index.js

@@ -0,0 +1 @@
+export {};

package/types/middlewares/parsing.d.ts

@@ -0,0 +1,41 @@
+import { OperationResult, OperationVariables, RequestContext, SubscriptionOperation, SyncOperation } from '../base.js';
+import { SubOpAsyncIterable } from '../parser.js';
+import { OpResultBasedOnOp, PromiseOrValue } from '../utils.js';
+export type BeforeParsingSyncMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends SyncOperation<unknown, unknown>>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: OperationVariables<T>;
+    init: RequestInit;
+    response: Response;
+}) => PromiseOrValue<Response>;
+export type BeforeParsingSubscriptionMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends SubscriptionOperation<unknown, unknown>>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: OperationVariables<T>;
+    init: RequestInit;
+    response: Response;
+    controller: AbortController;
+}) => PromiseOrValue<Response>;
+export interface AfterParsingSyncMiddlewareOptions<TClientContext, TRequestContext extends RequestContext, T extends SyncOperation<unknown, unknown>> {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: OperationVariables<T>;
+    init: RequestInit;
+    response: Response;
+    result: OpResultBasedOnOp<T>;
+}
+export interface AfterParsingSubscriptionMiddlewareOptions<TClientContext, TRequestContext extends RequestContext, T extends SubscriptionOperation<unknown, unknown>> {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: OperationVariables<T>;
+    init: RequestInit;
+    response: Response;
+    result: OpResultBasedOnOp<T>;
+    controller: AbortController;
+}
+export type AfterParsingSyncMiddleware<TClientContext, TRequestContext extends RequestContext> = <TSyncOp extends SyncOperation<unknown, unknown>>(options: AfterParsingSyncMiddlewareOptions<TClientContext, TRequestContext, TSyncOp>) => PromiseOrValue<OperationResult<TSyncOp>>;
+export type AfterParsingSubscriptionMiddleware<TClientContext, TRequestContext extends RequestContext> = <TSubOp extends SubscriptionOperation<unknown, unknown>>(options: AfterParsingSubscriptionMiddlewareOptions<TClientContext, TRequestContext, TSubOp>) => PromiseOrValue<SubOpAsyncIterable<OperationResult<TSubOp>>>;

package/types/middlewares/parsing.js

@@ -0,0 +1 @@
+export {};

package/types/middlewares/serialization.d.ts

@@ -0,0 +1,23 @@
+import { Operation, OperationVariables, RequestContext, SubscriptionOperation, SyncOperation } from '../base.js';
+import { PromiseOrValue } from '../utils.js';
+export type BeforeSerializationMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation<unknown, unknown>>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: OperationVariables<T>;
+}) => PromiseOrValue<[T, OperationVariables<T>]>;
+export type AfterSerializationSyncMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends SyncOperation<unknown, unknown>>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: OperationVariables<T>;
+    init: RequestInit;
+}) => PromiseOrValue<RequestInit>;
+export type AfterSerializationSubscriptionMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends SubscriptionOperation<unknown, unknown>>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: OperationVariables<T>;
+    init: RequestInit;
+    controller: AbortController;
+}) => PromiseOrValue<RequestInit>;

package/types/middlewares/serialization.js

@@ -0,0 +1 @@
+export {};

package/types/parser.d.ts

@@ -1,20 +1,25 @@
 import type { SubscriptionOperation, SyncOperation, RequestContext, Operation, OperationResult } from './base.js';
 import { PromiseOrValue } from './utils.js';
-export interface ClientParserParseBodyOptions<TClientContext, TRequestContext extends RequestContext, TOperation extends Operation<unknown, unknown>> {
+export interface ClientParserParseBodySyncOptions<TClientContext, TRequestContext extends RequestContext, TOperation extends Operation<unknown, unknown>> {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: TOperation;
     response: Response;
 }
-export type SubOpAsyncIterable<TResult> = {
+export interface ClientParserParseBodySubscriptionOptions<TClientContext, TRequestContext extends RequestContext, TOperation extends Operation<unknown, unknown>> {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: TOperation;
+    response: Response;
+    controller: AbortController;
+}
+export interface SubOpAsyncIterable<TResult> extends Disposable {
     stream: AsyncIterable<TResult, void, unknown>;
     close: () => void;
-};
-export type ParseBodyFuncType<TClientContext, TRequestContext extends RequestContext> = {
-    <TSyncOp extends SyncOperation<unknown, unknown>>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, TSyncOp>): PromiseOrValue<OperationResult<TSyncOp>>;
-    <TSubOp extends SubscriptionOperation<unknown, unknown>>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, TSubOp>): PromiseOrValue<SubOpAsyncIterable<OperationResult<TSubOp>>>;
-    <TOp extends Operation<unknown, unknown>>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, TOp>): PromiseOrValue<OperationResult<TOp>> | PromiseOrValue<SubOpAsyncIterable<OperationResult<TOp>>>;
-};
+}
+export type ParseBodySyncFuncType<TClientContext, TRequestContext extends RequestContext> = <TSyncOp extends SyncOperation<unknown, unknown>>(options: ClientParserParseBodySyncOptions<TClientContext, TRequestContext, TSyncOp>) => PromiseOrValue<OperationResult<TSyncOp>>;
+export type ParseBodySubscriptionFuncType<TClientContext, TRequestContext extends RequestContext> = <TSubOp extends SubscriptionOperation<unknown, unknown>>(options: ClientParserParseBodySubscriptionOptions<TClientContext, TRequestContext, TSubOp>) => PromiseOrValue<SubOpAsyncIterable<OperationResult<TSubOp>>>;
 export interface ClientParser<TClientContext, TRequestContext extends RequestContext> {
-    parseBody: ParseBodyFuncType<TClientContext, TRequestContext>;
+    parseBodySync: ParseBodySyncFuncType<TClientContext, TRequestContext>;
+    parseBodySubscription: ParseBodySubscriptionFuncType<TClientContext, TRequestContext>;
 }

package/execute.d.ts

@@ -1,12 +0,0 @@
-import { ClientConfig, Operation, OperationResult, OperationVariables, RequestContext, SubOpAsyncIterable, SubscriptionOperation, SyncOperation } from './types/index.js';
-import { OpResultBasedOnOp } from './types/utils.js';
-export interface ExecuteResult<TResult> {
-    result: TResult;
-    response: Response;
-}
-export declare function execute<TClientContext, TRequestContext extends RequestContext, T extends Operation<unknown, unknown>>(config: ClientConfig<TClientContext, TRequestContext>, operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): Promise<ExecuteResult<OpResultBasedOnOp<T>>>;
-export type Executor<TRequestContext extends RequestContext> = {
-    <TSyncOp extends SyncOperation<unknown, unknown>>(operation: TSyncOp, variables: OperationVariables<TSyncOp>, context: TRequestContext): Promise<ExecuteResult<OperationResult<TSyncOp>>>;
-    <TOperation extends SubscriptionOperation<unknown, unknown>>(operation: TOperation, variables: OperationVariables<TOperation>, context: TRequestContext): Promise<ExecuteResult<SubOpAsyncIterable<OperationResult<TOperation>>>>;
-};
-export declare function bindConfigToExecute<TClientContext, TRequestContext extends RequestContext>(config: ClientConfig<TClientContext, TRequestContext>): Executor<TRequestContext>;

package/execute.js

@@ -1,59 +0,0 @@
-export async function execute(config, operation, variables, requestContext) {
-    for (const middleware of config.middlewares.beforeSerialization) {
-        [operation, variables] = await middleware({
-            clientContext: config.context,
-            requestContext,
-            operation,
-            variables
-        });
-    }
-    let init = await config.serializer.serializeRequest({
-        clientContext: config.context,
-        requestContext,
-        operation,
-        variables
-    });
-    for (const middleware of config.middlewares.afterSerialization) {
-        init = await middleware({
-            clientContext: config.context,
-            requestContext,
-            operation,
-            variables,
-            init
-        });
-    }
-    let response = await config.fetcher(init);
-    for (const middleware of config.middlewares.beforeParsing) {
-        response = await middleware({
-            clientContext: config.context,
-            requestContext,
-            operation,
-            variables,
-            init,
-            response
-        });
-    }
-    let result = await config.parser.parseBody({
-        clientContext: config.context,
-        requestContext,
-        operation,
-        response
-    });
-    for (const middleware of config.middlewares.afterParsing) {
-        result = await middleware({
-            clientContext: config.context,
-            requestContext,
-            operation,
-            variables,
-            init,
-            response,
-            result
-        });
-    }
-    return { result, response };
-}
-export function bindConfigToExecute(config) {
-    return (operation, variables, requestContext) => execute(config, operation, variables, requestContext
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    );
-}

package/parser.js

@@ -1,58 +0,0 @@
-import assert from 'assert';
-const defaultParserOptions = {
-    onErrors(_, errors) {
-        throw new Error(JSON.stringify(errors));
-    },
-};
-export function createParser(parserOptions = defaultParserOptions) {
-    return {
-        parseBody: async (options
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ) => {
-            if (options.operation.type === 'SUBSCRIPTION') {
-                if (options.response.status !== 200) {
-                    throw new Error(await options.response.text());
-                }
-                assert(options.response.headers.get('content-type') ===
-                    'text/event-stream');
-                const rStream = options.response.body;
-                assert(rStream !== null);
-                const reader = rStream.getReader();
-                const decoder = new TextDecoder();
-                let shouldClose = false;
-                let resolve;
-                const signal = new Promise(res => resolve = res);
-                const close = () => {
-                    shouldClose = true;
-                    resolve({ done: true, value: undefined });
-                };
-                const stream = async function* () {
-                    while (!shouldClose) {
-                        const readResult = await Promise.race([
-                            reader.read(),
-                            signal
-                        ]);
-                        if (readResult.done || shouldClose)
-                            break;
-                        const lines = decoder.decode(readResult.value)
-                            .split('\n');
-                        for (const line of lines.filter(c => c !== '')) {
-                            if (shouldClose)
-                                return;
-                            const [name, value] = line.split(/:(.*)/s, 2);
-                            if (name !== 'data')
-                                continue;
-                            yield options.operation.resultSchema.parse(JSON.parse(value).data);
-                        }
-                    }
-                }();
-                return { stream, close };
-            }
-            const json = await options.response.json();
-            if (json.errors) {
-                await parserOptions.onErrors(options, json.errors);
-            }
-            return options.operation.resultSchema.parse(json.data);
-        },
-    };
-}

package/types/middlewares.d.ts

@@ -1,44 +0,0 @@
-import { Operation, SubscriptionOperation, SyncOperation, RequestContext, OperationVariables, OperationResult } from './base.js';
-import { SubOpAsyncIterable } from './parser.js';
-import { OpResultBasedOnOp, PromiseOrValue } from './utils.js';
-export type BeforeSerializationMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation<unknown, unknown>>(options: {
-    clientContext: TClientContext;
-    requestContext: TRequestContext;
-    operation: T;
-    variables: OperationVariables<T>;
-}) => PromiseOrValue<[T, OperationVariables<T>]>;
-export type AfterSerializationMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation<unknown, unknown>>(options: {
-    clientContext: TClientContext;
-    requestContext: TRequestContext;
-    operation: T;
-    variables: OperationVariables<T>;
-    init: RequestInit;
-}) => PromiseOrValue<RequestInit>;
-export type BeforeParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation<unknown, unknown>>(options: {
-    clientContext: TClientContext;
-    requestContext: TRequestContext;
-    operation: T;
-    variables: OperationVariables<T>;
-    init: RequestInit;
-    response: Response;
-}) => PromiseOrValue<Response>;
-export interface AfterParsingMiddlewareOptions<TClientContext, TRequestContext extends RequestContext, T extends Operation<unknown, unknown>> {
-    clientContext: TClientContext;
-    requestContext: TRequestContext;
-    operation: T;
-    variables: OperationVariables<T>;
-    init: RequestInit;
-    response: Response;
-    result: OpResultBasedOnOp<T>;
-}
-export type AfterParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = {
-    <TSyncOp extends SyncOperation<unknown, unknown>>(options: AfterParsingMiddlewareOptions<TClientContext, TRequestContext, TSyncOp>): PromiseOrValue<OperationResult<TSyncOp>>;
-    <TSubOp extends SubscriptionOperation<unknown, unknown>>(options: AfterParsingMiddlewareOptions<TClientContext, TRequestContext, TSubOp>): PromiseOrValue<SubOpAsyncIterable<OperationResult<TSubOp>>>;
-    <TOp extends Operation<unknown, unknown>>(options: AfterParsingMiddlewareOptions<TClientContext, TRequestContext, TOp>): PromiseOrValue<OperationResult<TOp>> | PromiseOrValue<SubOpAsyncIterable<OperationResult<TOp>>>;
-};
-export interface ClientMiddlewaresConfig<TClientContext, TRequestContext extends RequestContext> {
-    beforeSerialization: BeforeSerializationMiddleware<TClientContext, TRequestContext>[];
-    afterSerialization: AfterSerializationMiddleware<TClientContext, TRequestContext>[];
-    beforeParsing: BeforeParsingMiddleware<TClientContext, TRequestContext>[];
-    afterParsing: AfterParsingMiddleware<TClientContext, TRequestContext>[];
-}