@vladimirdev635/gql-client 0.0.74 → 0.0.76

package/executor.d.ts

@@ -2,6 +2,9 @@ import { ClientConfig, ExecuteResult, IExecutor, OperationResult, OperationVaria
 export declare class Executor<TClientContext, TRequestContext extends RequestContext> implements IExecutor<TRequestContext> {
     private readonly config;
     constructor(config: ClientConfig<TClientContext, TRequestContext>);
+    withRetry<T>(shouldRetry: (iteration: number, error: unknown) => boolean, execute: () => Promise<T>): Promise<T>;
     executeSync<T extends SyncOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): Promise<ExecuteResult<OperationResult<T>>>;
+    _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>>>>;
+    _executeSubscription<T extends SubscriptionOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext, controller: AbortController): Promise<ExecuteResult<SubOpAsyncIterable<OperationResult<T>>>>;
 }

package/executor.js

@@ -3,7 +3,30 @@ export class Executor {
     constructor(config) {
         this.config = config;
     }
+    async withRetry(shouldRetry, execute) {
+        let iteration = 0;
+        let error;
+        do {
+            try {
+                return await execute();
+            }
+            catch (e) {
+                error = e;
+                iteration++;
+            }
+        } while (shouldRetry(iteration, error));
+        throw error;
+    }
     async executeSync(operation, variables, requestContext) {
+        const retryOptions = {
+            context: this.config.context,
+            operation,
+            variables,
+            requestContext,
+        };
+        return await this.withRetry((iteration, error) => this.config.retryConfig.shouldSyncRetry(error, iteration, retryOptions), () => this._executeSync(operation, variables, requestContext));
+    }
+    async _executeSync(operation, variables, requestContext) {
         for (const middleware of this.config.middlewares.beforeSerialization) {
             [operation, variables] = await middleware({
                 clientContext: this.config.context,
@@ -58,6 +81,15 @@ export class Executor {
         return { result, response };
     }
     async executeSubscription(operation, variables, requestContext, controller) {
+        const retryOptions = {
+            context: this.config.context,
+            operation,
+            variables,
+            requestContext,
+        };
+        return await this.withRetry((iteration, error) => this.config.retryConfig.shouldSubscriptionRetry(error, iteration, retryOptions), () => this._executeSubscription(operation, variables, requestContext, controller));
+    }
+    async _executeSubscription(operation, variables, requestContext, controller) {
         for (const middleware of this.config.middlewares.beforeSerialization) {
             [operation, variables] = await middleware({
                 clientContext: this.config.context,

package/package.json

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

package/types/config.d.ts

@@ -1,11 +1,23 @@
-import { RequestContext } from './base.js';
+import { Operation, OperationVariables, RequestContext, SubscriptionOperation, SyncOperation } from './base.js';
 import { ClientMiddlewaresConfig } from './middlewares/config.js';
 import { ClientParser } from './parser.js';
 import { ClientSerializer } from './serializer.js';
+interface RetryConfigOptions<TClientContext, TRequestContext extends RequestContext, OperationType extends Operation<unknown, unknown>> {
+    context: TClientContext;
+    requestContext: TRequestContext;
+    operation: OperationType;
+    variables: OperationVariables<OperationType>;
+}
+interface RetryConfig<TClientContext, TRequestContext extends RequestContext> {
+    shouldSyncRetry: (error: unknown, iteration: number, options: RetryConfigOptions<TClientContext, TRequestContext, SyncOperation<unknown, unknown>>) => boolean;
+    shouldSubscriptionRetry: (error: unknown, iteration: number, options: RetryConfigOptions<TClientContext, TRequestContext, SubscriptionOperation<unknown, unknown>>) => boolean;
+}
 export interface ClientConfig<TClientContext, TRequestContext extends RequestContext> {
     context: TClientContext;
+    retryConfig: RetryConfig<TClientContext, TRequestContext>;
     parser: ClientParser<TClientContext, TRequestContext>;
     serializer: ClientSerializer<TClientContext, TRequestContext>;
     middlewares: ClientMiddlewaresConfig<TClientContext, TRequestContext>;
     fetcher: (init: RequestInit) => Promise<Response>;
 }
+export {};