@vladimirdev635/gql-client 0.0.46 → 0.0.48

package/execute.d.ts

@@ -1,12 +1,12 @@
-import { ClientConfig, Operation, OperationVariables, RequestContext, SubOpAsyncIterable, SubscriptionOperation, SyncOperation } from './types/index.js';
-import { OperationResult, OpResultBasedOnOp } from './types/utils.js';
+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>(config: ClientConfig<TClientContext, TRequestContext>, operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): Promise<ExecuteResult<OpResultBasedOnOp<T>>>;
+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>(operation: TSyncOp, variables: OperationVariables<TSyncOp>, context: TRequestContext): Promise<ExecuteResult<OperationResult<TSyncOp>>>;
-    <TOperation extends SubscriptionOperation>(operation: TOperation, variables: OperationVariables<TOperation>, context: TRequestContext): Promise<ExecuteResult<SubOpAsyncIterable<OperationResult<TOperation>>>>;
+    <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

@@ -53,5 +53,7 @@ export async function execute(config, operation, variables, requestContext) {
     return { result, response };
 }
 export function bindConfigToExecute(config) {
-    return (operation, variables, requestContext) => execute(config, operation, variables, requestContext);
+    return (operation, variables, requestContext) => execute(config, operation, variables, requestContext
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
 }

package/package.json

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

package/parser.d.ts

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

package/parser.js

@@ -6,7 +6,9 @@ const defaultParserOptions = {
 };
 export function createParser(parserOptions = defaultParserOptions) {
     return {
-        parseBody: async (options) => {
+        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());

package/types/base.d.ts

@@ -1,19 +1,21 @@
 import { z } from 'zod/v4';
-export interface SyncOperation {
-    type: 'QUERY' | 'MUTATION';
+export type SchemaFor<T> = z.ZodType<T>;
+interface BaseOperation<V, R> {
     name: string;
     document: string;
-    variablesSchema: z.ZodType;
-    resultSchema: z.ZodType;
+    variablesSchema: SchemaFor<V>;
+    resultSchema: SchemaFor<R>;
+}
+export interface SyncOperation<V, R> extends BaseOperation<V, R> {
+    type: 'QUERY' | 'MUTATION';
 }
-export interface SubscriptionOperation {
+export interface SubscriptionOperation<V, R> extends BaseOperation<V, R> {
     type: 'SUBSCRIPTION';
-    name: string;
-    document: string;
-    variablesSchema: z.ZodType;
-    resultSchema: z.ZodType;
 }
-export type Operation = SyncOperation | SubscriptionOperation;
+export type Operation<V, R> = SyncOperation<V, R> | SubscriptionOperation<V, R>;
 export interface RequestContext {
     fetchOptions?: RequestInit;
 }
+export type OperationVariables<T extends Operation<unknown, unknown>> = T extends Operation<infer V, unknown> ? V : never;
+export type OperationResult<T extends Operation<unknown, unknown>> = T extends Operation<unknown, infer R> ? R : never;
+export {};

package/types/index.d.ts

@@ -1,6 +1,6 @@
-export type { Operation, SyncOperation, SubscriptionOperation, RequestContext, } from './base.js';
+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 type { ClientSerializer } from './serializer.js';
 export type { ClientConfig } from './config.js';
-export type { OperationResult, OperationVariables, OpResultBasedOnOp } from './utils.js';
+export type { OpResultBasedOnOp } from './utils.js';

package/types/middlewares.d.ts

@@ -1,20 +1,20 @@
-import { Operation, SubscriptionOperation, SyncOperation, RequestContext } from './base.js';
+import { Operation, SubscriptionOperation, SyncOperation, RequestContext, OperationVariables, OperationResult } 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: {
+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>(options: {
+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>(options: {
+export type BeforeParsingMiddleware<TClientContext, TRequestContext extends RequestContext> = <T extends Operation<unknown, unknown>>(options: {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: T;
@@ -22,7 +22,7 @@ export type BeforeParsingMiddleware<TClientContext, TRequestContext extends Requ
     init: RequestInit;
     response: Response;
 }) => PromiseOrValue<Response>;
-export interface AfterParsingMiddlewareOptions<TClientContext, TRequestContext extends RequestContext, T extends Operation> {
+export interface AfterParsingMiddlewareOptions<TClientContext, TRequestContext extends RequestContext, T extends Operation<unknown, unknown>> {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: T;
@@ -32,9 +32,9 @@ export interface AfterParsingMiddlewareOptions<TClientContext, TRequestContext e
     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>>>;
+    <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>[];

package/types/parser.d.ts

@@ -1,6 +1,6 @@
-import type { SubscriptionOperation, SyncOperation, RequestContext, Operation } from './base.js';
-import { OperationResult, PromiseOrValue } from './utils.js';
-export interface ClientParserParseBodyOptions<TClientContext, TRequestContext extends RequestContext, TOperation> {
+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>> {
     clientContext: TClientContext;
     requestContext: TRequestContext;
     operation: TOperation;
@@ -11,9 +11,9 @@ export type SubOpAsyncIterable<TResult> = {
     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>>>;
+    <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 interface ClientParser<TClientContext, TRequestContext extends RequestContext> {
     parseBody: ParseBodyFuncType<TClientContext, TRequestContext>;

package/types/serializer.d.ts

@@ -1,7 +1,7 @@
-import { Operation, RequestContext } from './base.js';
-import { OperationVariables, PromiseOrValue } from './utils.js';
+import { Operation, OperationVariables, RequestContext } from './base.js';
+import { PromiseOrValue } from './utils.js';
 export interface ClientSerializer<TClientContext, TRequestContext extends RequestContext> {
-    serializeRequest: <T extends Operation>(options: {
+    serializeRequest: <T extends Operation<unknown, unknown>>(options: {
         clientContext: TClientContext;
         requestContext: TRequestContext;
         operation: T;

package/types/utils.d.ts

@@ -1,6 +1,3 @@
-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;
+export type OpResultBasedOnOp<T extends Operation<unknown, unknown>> = T extends SyncOperation<unknown, infer R> ? R : T extends SubscriptionOperation<unknown, infer R> ? AsyncIterable<R> : never;