@vladimirdev635/gql-client 0.0.24 → 0.0.26

package/execute.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod/v4';
-import { ClientConfig, Operation } from './types.js';
+import { ClientConfig, Operation, RequestContext } from './types/index.js';
 export interface ExecuteResult<T extends Operation> {
     result: z.infer<T['resultSchema']>;
     response: Response;
 }
-export declare function execute<TContext, T extends Operation>(config: ClientConfig<TContext>, operation: T, variables: z.infer<T['variablesSchema']>): Promise<ExecuteResult<T>>;
-export type Executor = <T extends Operation>(operation: T, variables: z.infer<T['variablesSchema']>) => Promise<ExecuteResult<T>>;
-export declare function bindConfigToExecute<TContext>(config: ClientConfig<TContext>): Executor;
+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<T>>;
+export type Executor<TRequestContext extends RequestContext> = <T extends Operation>(operation: T, variables: z.infer<T['variablesSchema']>, context: TRequestContext) => Promise<ExecuteResult<T>>;
+export declare function bindConfigToExecute<TClientContext, TRequestContext extends RequestContext>(config: ClientConfig<TClientContext, TRequestContext>): Executor<TRequestContext>;

package/execute.js

@@ -1,21 +1,57 @@
-export async function execute(config, operation, variables) {
+export async function execute(config, operation, variables, requestContext) {
     for (const middleware of config.middlewares.beforeSerialization) {
-        [operation, variables] = await middleware(config.context, operation, variables);
+        [operation, variables] = await middleware({
+            clientContext: config.context,
+            requestContext,
+            operation,
+            variables
+        });
     }
-    let init = await config.serializer.serializeRequest(config.context, operation, variables);
+    let init = await config.serializer.serializeRequest({
+        clientContext: config.context,
+        requestContext,
+        operation,
+        variables
+    });
     for (const middleware of config.middlewares.afterSerialization) {
-        init = await middleware(config.context, operation, variables, init);
+        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(config.context, operation, variables, init, response);
+        response = await middleware({
+            clientContext: config.context,
+            requestContext,
+            operation,
+            variables,
+            init,
+            response
+        });
     }
-    let result = await config.parser.parseBody(config.context, operation, response);
+    let result = await config.parser.parseBody({
+        clientContext: config.context,
+        requestContext,
+        operation,
+        response
+    });
     for (const middleware of config.middlewares.afterParsing) {
-        result = await middleware(config.context, operation, variables, init, response, result);
+        result = await middleware({
+            clientContext: config.context,
+            requestContext,
+            operation,
+            variables,
+            init,
+            response,
+            result
+        });
     }
     return { result, response };
 }
 export function bindConfigToExecute(config) {
-    return (operation, variables) => execute(config, operation, variables);
+    return (operation, variables, requestContext) => execute(config, operation, variables, requestContext);
 }

package/index.d.ts

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

package/index.js

@@ -1,2 +1,3 @@
 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.24",
+    "version": "0.0.26",
     "type": "module",
     "main": "./index.js",
     "types": "./index.d.ts",

package/parser.d.ts

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

package/parser.js

@@ -1,16 +1,16 @@
 const defaultParserOptions = {
-    onErrors(_, __, ___, errors) {
+    onErrors(_, errors) {
         throw new Error(JSON.stringify(errors));
     },
 };
-export function createParser(options = defaultParserOptions) {
+export function createParser(parserOptions = defaultParserOptions) {
     return {
-        parseBody: async (context, operation, response) => {
-            const json = await response.json();
+        parseBody: async (options) => {
+            const json = await options.response.json();
             if (json.errors) {
-                await options.onErrors(context, operation, response, json.errors);
+                await parserOptions.onErrors(options, json.errors);
             }
-            return operation.resultSchema.parse(json.data);
+            return options.operation.resultSchema.parse(json.data);
         },
     };
 }

package/serializers/json.d.ts

@@ -1,2 +1,2 @@
-import { ClientSerializer } from '@/types.js';
-export declare function createJSONSerializer<TContext>(): ClientSerializer<TContext>;
+import { ClientSerializer, RequestContext } from '@/types/index.js';
+export declare function createJSONSerializer<TClientContext, TRequestContext extends RequestContext>(): ClientSerializer<TClientContext, TRequestContext>;

package/serializers/json.js

@@ -1,11 +1,12 @@
 import assert from 'assert';
 export function createJSONSerializer() {
     return {
-        serializeRequest: (_, operation, variables) => {
+        serializeRequest: ({ operation, variables }) => {
             return {
                 headers: {
                     'Content-Type': 'application/json'
                 },
+                method: 'POST',
                 body: JSON.stringify({
                     query: operation.document,
                     variables

package/serializers/multipart.d.ts

@@ -1,2 +1,2 @@
-import { ClientSerializer } from '@/types.js';
-export declare function createMultipartSerializer<TContext>(): ClientSerializer<TContext>;
+import { ClientSerializer, RequestContext } from '@/types/index.js';
+export declare function createMultipartSerializer<TClientContext, TRequestContext extends RequestContext>(): ClientSerializer<TClientContext, TRequestContext>;

package/serializers/multipart.js

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

package/serializers/serializer.d.ts

@@ -1,3 +1,4 @@
-import { ClientSerializer } from '../types.js';
+import { RequestContext } from '@/types/base.js';
+import { ClientSerializer } from '@/types/serializer.js';
 export declare function hasBlobValue(data: any): boolean;
-export declare function createSerializer<TContext>(jsonSerializer: ClientSerializer<TContext>, multipartSerializer: ClientSerializer<TContext>, shouldUseMultipartSerializer?: (variables: any) => boolean): ClientSerializer<TContext>;
+export declare function createSerializer<TClientContext, TRequestContext extends RequestContext>(jsonSerializer: ClientSerializer<TClientContext, TRequestContext>, multipartSerializer: ClientSerializer<TClientContext, TRequestContext>, shouldUseMultipartSerializer?: (variables: any) => boolean): ClientSerializer<TClientContext, TRequestContext>;

package/serializers/serializer.js

@@ -17,11 +17,11 @@ export function createSerializer(jsonSerializer, multipartSerializer,
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 shouldUseMultipartSerializer = hasBlobValue) {
     return {
-        serializeRequest: (context, operation, variables) => {
-            if (!shouldUseMultipartSerializer(variables)) {
-                return jsonSerializer.serializeRequest(context, operation, variables);
+        serializeRequest: (options) => {
+            if (!shouldUseMultipartSerializer(options.variables)) {
+                return jsonSerializer.serializeRequest(options);
             }
-            return multipartSerializer.serializeRequest(context, operation, variables);
+            return multipartSerializer.serializeRequest(options);
         },
     };
 }

package/serializers/tests/json.spec.js

@@ -6,6 +6,8 @@ describe('Json serializer', () => {
     it('Should crush if files are present', async () => {
         const operation = {
             document: 'test-document',
+            name: '',
+            type: 'QUERY',
             variablesSchema: z.object({
                 name: z.string(),
                 file: z.file(),
@@ -16,11 +18,18 @@ describe('Json serializer', () => {
             name: 'test-name',
             file: new File([], '')
         };
-        expect(() => jsonSerializer.serializeRequest({}, operation, variables)).toThrowError('jsonSerializer cannot encode File objects, key: "file"');
+        expect(() => jsonSerializer.serializeRequest({
+            operation,
+            variables,
+            clientContext: {},
+            requestContext: {}
+        })).toThrowError('jsonSerializer cannot encode File objects, key: "file"');
     });
     it('Should json stringify variables', async () => {
         const operation = {
             document: 'test-document',
+            name: '',
+            type: 'QUERY',
             variablesSchema: z.object({
                 name: z.string(),
             }),
@@ -29,7 +38,12 @@ describe('Json serializer', () => {
         const variables = {
             name: 'test-name',
         };
-        const init = await jsonSerializer.serializeRequest({}, operation, variables);
+        const init = await jsonSerializer.serializeRequest({
+            clientContext: {},
+            requestContext: {},
+            operation,
+            variables
+        });
         const headers = new Headers(init.headers);
         expect(headers.get('Content-Type')).toBe('application/json');
         expect(init.body).toBe(JSON.stringify({

package/serializers/tests/multipart.spec.js

@@ -7,6 +7,8 @@ describe('Multipart serializer', () => {
     it('Should crush if no files present', () => {
         const operation = {
             document: 'test-document',
+            name: '',
+            type: 'QUERY',
             variablesSchema: z.object({
                 name: z.string()
             }),
@@ -15,11 +17,18 @@ describe('Multipart serializer', () => {
         const variables = {
             name: 'test-name'
         };
-        expect(() => multipartSerializer.serializeRequest({}, operation, variables)).toThrowError('Dont use multipartSerializer for regular bodies');
+        expect(() => multipartSerializer.serializeRequest({
+            clientContext: {},
+            requestContext: {},
+            operation,
+            variables
+        })).toThrowError('Dont use multipartSerializer for regular bodies');
     });
     it('Should build proper form data', async () => {
         const operation = {
             document: 'test-document',
+            name: '',
+            type: 'QUERY',
             variablesSchema: z.object({
                 name: z.string(),
                 file: z.file()
@@ -30,7 +39,12 @@ describe('Multipart serializer', () => {
             name: 'test-name',
             file: new File([], 'check.txt')
         };
-        const init = await multipartSerializer.serializeRequest({}, operation, variables);
+        const init = await multipartSerializer.serializeRequest({
+            clientContext: {},
+            requestContext: {},
+            operation,
+            variables
+        });
         const headers = new Headers(init.headers);
         expect(headers.get('Content-Type')).toBe('multipart/form-data');
         assert(init.body != null);

package/types/base.d.ts

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

package/types/config.d.ts

@@ -0,0 +1,11 @@
+import { RequestContext } from './base.js';
+import { ClientMiddlewaresConfig } from './middlewares.js';
+import { ClientParser } from './parser.js';
+import { ClientSerializer } from './serializer.js';
+export interface ClientConfig<TClientContext, TRequestContext extends RequestContext> {
+    context: TClientContext;
+    parser: ClientParser<TClientContext, TRequestContext>;
+    serializer: ClientSerializer<TClientContext, TRequestContext>;
+    middlewares: ClientMiddlewaresConfig<TClientContext, TRequestContext>;
+    fetcher: (init: RequestInit) => Promise<Response>;
+}

package/types/config.js

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

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { Operation, RequestContext } from './base.js';
+export type { BeforeSerializationMiddleware, AfterSerializationMiddleware, BeforeParsingMiddleware, AfterParsingMiddleware, ClientMiddlewaresConfig } from './middlewares.js';
+export type { ClientParser } from './parser.js';
+export type { ClientSerializer } from './serializer.js';
+export type { ClientConfig } from './config.js';

package/types/index.js

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

package/types/middlewares.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod/v4';
+import { Operation, RequestContext } from './base.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']>
+];
+export type AfterSerializationMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: z.infer<T['variablesSchema']>;
+    init: RequestInit;
+}) => Promise<RequestInit> | RequestInit;
+export type BeforeParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: z.infer<T['variablesSchema']>;
+    init: RequestInit;
+    response: Response;
+}) => Promise<Response> | Response;
+export type AfterParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation>(options: {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    variables: z.infer<T['variablesSchema']>;
+    init: RequestInit;
+    response: Response;
+    result: z.infer<T['resultSchema']>;
+}) => Promise<z.infer<T['resultSchema']>> | z.infer<T['resultSchema']>;
+export interface ClientMiddlewaresConfig<TClientContext, TRequestContext extends RequestContext> {
+    beforeSerialization: BeforeSerializationMiddleware<TClientContext, TRequestContext>[];
+    afterSerialization: AfterSerializationMiddleware<TClientContext, TRequestContext>[];
+    beforeParsing: BeforeParsingMiddleware<TClientContext, TRequestContext>[];
+    afterParsing: AfterParsingMiddleware<TClientContext, TRequestContext>[];
+}

package/types/middlewares.js

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

package/types/parser.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod/v4';
+import { Operation, RequestContext } from './base.js';
+export interface ClientParserParseBodyOptions<TClientContext, TRequestContext extends RequestContext, T extends Operation> {
+    clientContext: TClientContext;
+    requestContext: TRequestContext;
+    operation: T;
+    response: Response;
+}
+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']>;
+}

package/types/parser.js

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

package/types/serializer.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod/v4';
+import { Operation, RequestContext } from './base.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;
+}

package/types/serializer.js

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

package/types.d.ts

@@ -1,32 +0,0 @@
-import { z } from 'zod/v4';
-export interface Operation {
-    document: string;
-    variablesSchema: z.ZodType;
-    resultSchema: z.ZodType;
-}
-export interface ClientParser<TContext> {
-    parseBody: <T extends Operation>(context: TContext, operation: T, response: Response) => Promise<z.infer<T['resultSchema']>> | z.infer<T['resultSchema']>;
-}
-export interface ClientSerializer<TContext> {
-    serializeRequest: <T extends Operation>(context: TContext, operation: T, variables: z.infer<T['variablesSchema']>) => Promise<RequestInit> | RequestInit;
-}
-export type BeforeSerializationMiddleware<TContext> = <T extends Operation>(context: TContext, operation: T, variables: z.infer<T['variablesSchema']>) => Promise<[T, z.infer<T['variablesSchema']>]> | [
-    T,
-    z.infer<T['variablesSchema']>
-];
-export type AfterSerializationMiddleware<TContext> = <T extends Operation>(context: TContext, operation: T, variables: z.infer<T['variablesSchema']>, init: RequestInit) => Promise<RequestInit> | RequestInit;
-export type BeforeParsingMiddleware<TContext> = <T extends Operation>(context: TContext, operation: T, variables: z.infer<T['variablesSchema']>, init: RequestInit, response: Response) => Promise<Response> | Response;
-export type AfterParsingMiddleware<TContext> = <T extends Operation>(context: TContext, operation: T, variables: z.infer<T['variablesSchema']>, init: RequestInit, response: Response, result: z.infer<T['resultSchema']>) => Promise<z.infer<T['resultSchema']>> | z.infer<T['resultSchema']>;
-export interface ClientMiddlewaresConfig<TContext> {
-    beforeSerialization: BeforeSerializationMiddleware<TContext>[];
-    afterSerialization: AfterSerializationMiddleware<TContext>[];
-    beforeParsing: BeforeParsingMiddleware<TContext>[];
-    afterParsing: AfterParsingMiddleware<TContext>[];
-}
-export interface ClientConfig<TContext> {
-    parser: ClientParser<TContext>;
-    serializer: ClientSerializer<TContext>;
-    middlewares: ClientMiddlewaresConfig<TContext>;
-    context: TContext;
-    fetcher: (init: RequestInit) => Promise<Response>;
-}