@vladimirdev635/gql-client 0.0.41 → 0.0.43

package/execute.d.ts

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

package/index.d.ts

@@ -1,4 +1,4 @@
-export { createParser } from './parser.js';
+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, RequestContext, ClientParser, ClientSerializer, ClientConfig, ClientMiddlewaresConfig, BeforeSerializationMiddleware, AfterSerializationMiddleware, BeforeParsingMiddleware, AfterParsingMiddleware, } from './types/index.js';
+export type { Operation, SyncOperation, SubscriptionOperation, RequestContext, ClientParser, ClientSerializer, ClientConfig, ClientMiddlewaresConfig, BeforeSerializationMiddleware, AfterSerializationMiddleware, BeforeParsingMiddleware, AfterParsingMiddleware, OpResultBasedOnOp, OperationVariables, OperationResult } from './types/index.js';

package/index.js

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

package/package.json

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

package/parser.d.ts

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

package/parser.js

@@ -1,3 +1,4 @@
+import assert from 'assert';
 const defaultParserOptions = {
     onErrors(_, errors) {
         throw new Error(JSON.stringify(errors));
@@ -6,6 +7,37 @@ const defaultParserOptions = {
 export function createParser(parserOptions = defaultParserOptions) {
     return {
         parseBody: async (options) => {
+            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 stream = options.response.body;
+                assert(stream !== null);
+                const reader = stream.getReader();
+                const decoder = new TextDecoder();
+                let shouldClose = false;
+                const cancel = () => shouldClose = true;
+                const streamGen = async function* () {
+                    while (!shouldClose) {
+                        const readResult = await reader.read();
+                        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: streamGen, cancel };
+            }
             const json = await options.response.json();
             if (json.errors) {
                 await parserOptions.onErrors(options, json.errors);

package/serializers/json.js

@@ -1,11 +1,15 @@
 import assert from 'assert';
 export function createJSONSerializer() {
     return {
-        serializeRequest: ({ operation, variables }) => {
+        serializeRequest: ({ operation, requestContext, variables }) => {
+            const headers = {
+                'Content-Type': 'application/json'
+            };
+            if (operation.type === 'SUBSCRIPTION') {
+                headers.Accept = 'text/event-stream';
+            }
             return {
-                headers: {
-                    'Content-Type': 'application/json'
-                },
+                headers,
                 method: 'POST',
                 body: JSON.stringify({
                     query: operation.document,
@@ -14,7 +18,8 @@ export function createJSONSerializer() {
                     assert(!(value instanceof File), 'jsonSerializer cannot encode File objects, ' +
                         `key: "${key}"`);
                     return value;
-                })
+                }),
+                ...requestContext.fetchOptions
             };
         },
     };

package/serializers/multipart.js

@@ -55,13 +55,14 @@ function buildFormData(operation, variables, shouldTreatAsObject) {
 }
 export function createMultipartSerializer() {
     return {
-        serializeRequest: ({ operation, variables }) => {
+        serializeRequest: ({ operation, requestContext, variables }) => {
             return {
                 headers: {
                     'Content-Type': 'multipart/form-data'
                 },
                 method: 'POST',
-                body: buildFormData(operation, variables)
+                body: buildFormData(operation, variables),
+                ...requestContext.fetchOptions
             };
         },
     };

package/types/base.d.ts

@@ -1,11 +1,19 @@
 import { z } from 'zod/v4';
-export interface Operation {
-    type: 'QUERY' | 'MUTATION' | 'SUBSCRIPTION';
+export interface SyncOperation {
+    type: 'QUERY' | 'MUTATION';
     name: string;
     document: string;
     variablesSchema: z.ZodType;
     resultSchema: z.ZodType;
 }
+export interface SubscriptionOperation {
+    type: 'SUBSCRIPTION';
+    name: string;
+    document: string;
+    variablesSchema: z.ZodType;
+    resultSchema: z.ZodType;
+}
+export type Operation = SyncOperation | SubscriptionOperation;
 export interface RequestContext {
     fetchOptions?: RequestInit;
 }

package/types/index.d.ts

@@ -1,5 +1,6 @@
-export type { Operation, RequestContext } from './base.js';
+export type { Operation, SyncOperation, SubscriptionOperation, RequestContext, } from './base.js';
 export type { BeforeSerializationMiddleware, AfterSerializationMiddleware, BeforeParsingMiddleware, AfterParsingMiddleware, ClientMiddlewaresConfig } from './middlewares.js';
-export type { ClientParser } from './parser.js';
+export type { ClientParser, SubOpAsyncIterable } from './parser.js';
 export type { ClientSerializer } from './serializer.js';
 export type { ClientConfig } from './config.js';
+export type { OperationResult, OperationVariables, OpResultBasedOnOp } from './utils.js';

package/types/middlewares.d.ts

@@ -1,38 +1,41 @@
-import { z } from 'zod/v4';
-import { Operation, RequestContext } from './base.js';
+import { Operation, SubscriptionOperation, SyncOperation, RequestContext } from './base.js';
+import { SubOpAsyncIterable } from './parser.js';
+import { OperationResult, OperationVariables, OpResultBasedOnOp, PromiseOrValue } from './utils.js';
 export type BeforeSerializationMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation>(options: {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: T;
-    variables: z.infer<T['variablesSchema']>;
-}) => Promise<[T, z.infer<T['variablesSchema']>]> | [
-    T,
-    z.infer<T['variablesSchema']>
-];
+    variables: OperationVariables<T>;
+}) => PromiseOrValue<[T, OperationVariables<T>]>;
 export type AfterSerializationMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation>(options: {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: T;
-    variables: z.infer<T['variablesSchema']>;
+    variables: OperationVariables<T>;
     init: RequestInit;
-}) => Promise<RequestInit> | RequestInit;
+}) => PromiseOrValue<RequestInit>;
 export type BeforeParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation>(options: {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: T;
-    variables: z.infer<T['variablesSchema']>;
+    variables: OperationVariables<T>;
     init: RequestInit;
     response: Response;
-}) => Promise<Response> | Response;
-export type AfterParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation>(options: {
+}) => PromiseOrValue<Response>;
+export interface AfterParsingMiddlewareOptions<TClientContext, TRequestContext extends RequestContext, T extends Operation> {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: T;
-    variables: z.infer<T['variablesSchema']>;
+    variables: OperationVariables<T>;
     init: RequestInit;
     response: Response;
-    result: z.infer<T['resultSchema']>;
-}) => Promise<z.infer<T['resultSchema']>> | z.infer<T['resultSchema']>;
+    result: OpResultBasedOnOp<T>;
+}
+export type AfterParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = {
+    <TSyncOp extends SyncOperation>(options: AfterParsingMiddlewareOptions<TClientContext, TRequestContext, TSyncOp>): PromiseOrValue<OperationResult<TSyncOp>>;
+    <TSubOp extends SubscriptionOperation>(options: AfterParsingMiddlewareOptions<TClientContext, TRequestContext, TSubOp>): PromiseOrValue<SubOpAsyncIterable<OperationResult<TSubOp>>>;
+    <TOp extends Operation>(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>[];

package/types/parser.d.ts

@@ -1,11 +1,20 @@
-import { z } from 'zod/v4';
-import { Operation, RequestContext } from './base.js';
-export interface ClientParserParseBodyOptions<TClientContext, TRequestContext extends RequestContext, T extends Operation> {
+import type { SubscriptionOperation, SyncOperation, RequestContext, Operation } from './base.js';
+import { OperationResult, PromiseOrValue } from './utils.js';
+export interface ClientParserParseBodyOptions<TClientContext, TRequestContext extends RequestContext, TOperation> {
     clientContext: TClientContext;
     requestContext: TRequestContext;
-    operation: T;
+    operation: TOperation;
     response: Response;
 }
+export type SubOpAsyncIterable<TResult> = {
+    stream: AsyncIterable<TResult, void, unknown>;
+    close: () => void;
+};
+export type ParseBodyFuncType<TClientContext, TRequestContext extends RequestContext> = {
+    <TSyncOp extends SyncOperation>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, TSyncOp>): PromiseOrValue<OperationResult<TSyncOp>>;
+    <TSubOp extends SubscriptionOperation>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, TSubOp>): PromiseOrValue<SubOpAsyncIterable<OperationResult<TSubOp>>>;
+    <TOp extends Operation>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, TOp>): PromiseOrValue<OperationResult<TOp>> | PromiseOrValue<SubOpAsyncIterable<OperationResult<TOp>>>;
+};
 export interface ClientParser<TClientContext, TRequestContext extends RequestContext> {
-    parseBody: <T extends Operation>(options: ClientParserParseBodyOptions<TClientContext, TRequestContext, T>) => Promise<z.infer<T['resultSchema']>> | z.infer<T['resultSchema']>;
+    parseBody: ParseBodyFuncType<TClientContext, TRequestContext>;
 }

package/types/serializer.d.ts

@@ -1,10 +1,10 @@
-import { z } from 'zod/v4';
 import { Operation, RequestContext } from './base.js';
+import { OperationVariables, PromiseOrValue } from './utils.js';
 export interface ClientSerializer<TClientContext, TRequestContext extends RequestContext> {
     serializeRequest: <T extends Operation>(options: {
         clientContext: TClientContext;
         requestContext: TRequestContext;
         operation: T;
-        variables: z.infer<T['variablesSchema']>;
-    }) => Promise<RequestInit> | RequestInit;
+        variables: OperationVariables<T>;
+    }) => PromiseOrValue<RequestInit>;
 }

package/types/utils.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod/v4';
+import { Operation, SubscriptionOperation, SyncOperation } from './base.js';
+export type PromiseOrValue<T> = Promise<T> | T;
+export type OperationResult<T extends Operation> = z.infer<T['resultSchema']>;
+export type OperationVariables<T extends Operation> = z.infer<T['variablesSchema']>;
+export type OpResultBasedOnOp<T extends Operation> = T extends SyncOperation ? OperationResult<T> : T extends SubscriptionOperation ? AsyncIterable<OperationResult<T>> : never;

package/types/utils.js

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