@jackchuka/gql-ingest 1.2.0 → 1.4.0

package/dist/config.d.ts

@@ -3,19 +3,30 @@ export interface ParallelProcessingConfig {
     entityConcurrency: number;
     preserveRowOrder: boolean;
 }
+export interface RetryConfig {
+    maxAttempts: number;
+    baseDelay: number;
+    maxDelay: number;
+    exponentialBackoff: boolean;
+    retryableStatusCodes: number[];
+}
 export interface EntityConfig {
     concurrency?: number;
     preserveRowOrder?: boolean;
+    retry?: Partial<RetryConfig>;
 }
 export interface ProcessingConfig {
+    retry: RetryConfig;
     parallelProcessing: ParallelProcessingConfig;
     entityConfig: Record<string, EntityConfig>;
     entityDependencies: Record<string, string[]>;
 }
 export interface FullConfig extends ProcessingConfig {
 }
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
 export declare const DEFAULT_PARALLEL_CONFIG: ParallelProcessingConfig;
 export declare const DEFAULT_CONFIG: ProcessingConfig;
 export declare function loadConfig(configDir: string): ProcessingConfig;
 export declare function getEntityConfig(entityName: string, globalConfig: ProcessingConfig): ParallelProcessingConfig;
+export declare function getRetryConfig(entityName: string, globalConfig: ProcessingConfig): RetryConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,kBAAkB,EAAE,wBAAwB,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,UAAW,SAAQ,gBAAgB;CAEnD;AAED,eAAO,MAAM,uBAAuB,EAAE,wBAIrC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAI5B,CAAC;AAEF,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAmB9D;AAaD,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,gBAAgB,GAC7B,wBAAwB,CAiB1B"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,oBAAoB,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,kBAAkB,EAAE,wBAAwB,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,UAAW,SAAQ,gBAAgB;CAEnD;AAED,eAAO,MAAM,oBAAoB,EAAE,WAMlC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,wBAIrC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAK5B,CAAC;AAEF,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAmB9D;AAiBD,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,gBAAgB,GAC7B,wBAAwB,CAiB1B;AAED,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,gBAAgB,GAC7B,WAAW,CAOb"}

package/dist/graphql-client.d.ts

@@ -1,10 +1,14 @@
-import { MetricsCollector } from './metrics';
+import { MetricsCollector } from "./metrics";
+import { RetryConfig } from "./config";
 export declare class GraphQLClientWrapper {
     private client;
     private metrics?;
     private verbose;
     constructor(endpoint: string, headers?: Record<string, string>, metrics?: MetricsCollector, verbose?: boolean);
-    executeMutation(mutation: string, variables: Record<string, any>): Promise<any>;
+    executeMutation(mutation: string, variables: Record<string, any>, retryConfig?: RetryConfig): Promise<any>;
+    private isRetryableError;
+    private calculateDelay;
+    private sleep;
     setHeaders(headers: Record<string, string>): void;
 }
 //# sourceMappingURL=graphql-client.d.ts.map

package/dist/graphql-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql-client.d.ts","sourceRoot":"","sources":["../src/graphql-client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAAC,CAAmB;IACnC,OAAO,CAAC,OAAO,CAAU;gBAEb,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,EAAE,OAAO,GAAE,OAAe;IAQ9G,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC;IA+BrF,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAG3C"}
+{"version":3,"file":"graphql-client.d.ts","sourceRoot":"","sources":["../src/graphql-client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAwB,WAAW,EAAE,MAAM,UAAU,CAAC;AAE7D,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAAC,CAAmB;IACnC,OAAO,CAAC,OAAO,CAAU;gBAGvB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,CAAC,EAAE,gBAAgB,EAC1B,OAAO,GAAE,OAAe;IASpB,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,GAAG,CAAC;IA6Ff,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,KAAK;IAIb,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAG3C"}

package/dist/mapper.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLClientWrapper } from "./graphql-client";
 import { MetricsCollector } from "./metrics";
-import { ParallelProcessingConfig } from "./config";
+import { ParallelProcessingConfig, RetryConfig } from "./config";
 export interface MappingConfig {
     csvFile: string;
     graphqlFile: string;
@@ -13,11 +13,14 @@ export declare class DataMapper {
     private verbose;
     constructor(client: GraphQLClientWrapper, basePath?: string, metrics?: MetricsCollector, verbose?: boolean);
     discoverMappings(configDir: string): string[];
-    processEntity(configPath: string, parallelConfig?: ParallelProcessingConfig): Promise<void>;
+    processEntity(configPath: string, parallelConfig?: ParallelProcessingConfig, retryConfig?: RetryConfig): Promise<void>;
     private processRowsSequentially;
     private processRowsConcurrently;
     private chunkArray;
     private mapCsvRowToVariables;
+    private extractVariableTypes;
+    private extractTypeName;
+    private convertValue;
     getMetrics(): MetricsCollector;
 }
 //# sourceMappingURL=mapper.d.ts.map

package/dist/mapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../src/mapper.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAAU;gBAGvB,MAAM,EAAE,oBAAoB,EAC5B,QAAQ,GAAE,MAAsB,EAChC,OAAO,CAAC,EAAE,gBAAgB,EAC1B,OAAO,GAAE,OAAe;IAQ1B,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAiBvC,aAAa,CACjB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,wBAAwB,GACxC,OAAO,CAAC,IAAI,CAAC;YA4CF,uBAAuB;YA8BvB,uBAAuB;IAkErC,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,oBAAoB;IAe5B,UAAU,IAAI,gBAAgB;CAG/B"}
+{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../src/mapper.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEjE,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAAU;gBAGvB,MAAM,EAAE,oBAAoB,EAC5B,QAAQ,GAAE,MAAsB,EAChC,OAAO,CAAC,EAAE,gBAAgB,EAC1B,OAAO,GAAE,OAAe;IAQ1B,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAiBvC,aAAa,CACjB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,wBAAwB,EACzC,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,IAAI,CAAC;YA8CF,uBAAuB;YAwCvB,uBAAuB;IA8ErC,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,oBAAoB;IAkB5B,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,YAAY;IAsDpB,UAAU,IAAI,gBAAgB;CAG/B"}

package/dist/metrics.d.ts

@@ -11,6 +11,9 @@ export interface ProcessingMetrics {
     totalFailures: number;
     entityMetrics: Map<string, EntityMetrics>;
     requestDurations: number[];
+    retryAttempts: number;
+    retrySuccesses: number;
+    retryFailures: number;
     startTime: number;
     endTime?: number;
 }
@@ -26,6 +29,8 @@ export declare class MetricsCollector {
     getTotalProcessed(): number;
     getSuccessRate(): number;
     recordRequestDuration(duration: number): void;
+    recordRetrySuccess(attempts: number): void;
+    recordRetryFailure(attempts: number): void;
     getAverageRequestDuration(): number;
     getDurationMs(): number;
     generateSummary(): string;

package/dist/metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC1C,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAoB;;IAanC,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAW/C,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASvC,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASvC,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOhD,gBAAgB,IAAI,iBAAiB;IAKrC,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D,iBAAiB,IAAI,MAAM;IAI3B,cAAc,IAAI,MAAM;IAKxB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI7C,yBAAyB,IAAI,MAAM;IAMnC,aAAa,IAAI,MAAM;IAKvB,eAAe,IAAI,MAAM;CA6B1B"}
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC1C,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAoB;;IAgBnC,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAW/C,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASvC,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASvC,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOhD,gBAAgB,IAAI,iBAAiB;IAKrC,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D,iBAAiB,IAAI,MAAM;IAI3B,cAAc,IAAI,MAAM;IAKxB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI7C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK1C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK1C,yBAAyB,IAAI,MAAM;IAMnC,aAAa,IAAI,MAAM;IAKvB,eAAe,IAAI,MAAM;CAmC1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackchuka/gql-ingest",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "A CLI tool for ingesting data from CSV files into a GraphQL API",
   "type": "module",
   "main": "dist/cli.js",

package/src/cli.ts

@@ -2,7 +2,7 @@ import { Command } from "commander";
 import { GraphQLClientWrapper } from "./graphql-client";
 import { DataMapper } from "./mapper";
 import { MetricsCollector } from "./metrics";
-import { loadConfig, getEntityConfig } from "./config";
+import { loadConfig, getEntityConfig, getRetryConfig } from "./config";
 import { DependencyResolver } from "./dependency-resolver";
 import { basename } from "path";
 
@@ -114,7 +114,8 @@ async function processEntitiesSequentially(
     try {
       const entityName = basename(configPath, ".json");
       const entityConfig = getEntityConfig(entityName, config);
-      await mapper.processEntity(configPath, entityConfig);
+      const retryConfig = getRetryConfig(entityName, config);
+      await mapper.processEntity(configPath, entityConfig, retryConfig);
     } catch (error) {
       console.warn(`Warning: Could not process ${configPath}:`, error);
     }
@@ -142,14 +143,15 @@ async function processEntitiesInWaves(
     // Process entities in controlled batches based on entityConcurrency
     const entityConcurrency = config.parallelProcessing.entityConcurrency;
     const chunks = chunkArray(wave.entities, entityConcurrency);
-    
+
     for (const chunk of chunks) {
       const entityPromises = chunk.map(async (entityName) => {
         const configPath = pathMap.get(entityName);
         if (configPath) {
           try {
             const entityConfig = getEntityConfig(entityName, config);
-            await mapper.processEntity(configPath, entityConfig);
+            const retryConfig = getRetryConfig(entityName, config);
+            await mapper.processEntity(configPath, entityConfig, retryConfig);
           } catch (error) {
             console.warn(`Warning: Could not process ${configPath}:`, error);
           }

package/src/config.test.ts

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { loadConfig, getEntityConfig, DEFAULT_CONFIG } from "./config";
+import { loadConfig, getEntityConfig, getRetryConfig, DEFAULT_CONFIG } from "./config";
 
 jest.mock("fs");
 const mockFs = fs as jest.Mocked<typeof fs>;
@@ -112,6 +112,13 @@ entityConfig:
 
   describe("getEntityConfig", () => {
     const globalConfig = {
+      retry: {
+        maxAttempts: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        exponentialBackoff: true,
+        retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+      },
       parallelProcessing: {
         concurrency: 10,
         entityConcurrency: 3,
@@ -201,4 +208,65 @@ entityConfig:
       consoleSpy.mockRestore();
     });
   });
+
+  describe("getRetryConfig", () => {
+    const globalConfig = {
+      retry: {
+        maxAttempts: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        exponentialBackoff: true,
+        retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+      },
+      parallelProcessing: {
+        concurrency: 10,
+        entityConcurrency: 3,
+        preserveRowOrder: false,
+      },
+      entityConfig: {
+        important: {
+          retry: {
+            maxAttempts: 5,
+            baseDelay: 500,
+          },
+        },
+        fast: {
+          retry: {
+            maxAttempts: 1,
+          },
+        },
+      },
+      entityDependencies: {},
+    };
+
+    it("should return global retry config for entity without overrides", () => {
+      const retryConfig = getRetryConfig("regular", globalConfig);
+
+      expect(retryConfig).toEqual(globalConfig.retry);
+    });
+
+    it("should merge entity retry overrides with global config", () => {
+      const retryConfig = getRetryConfig("important", globalConfig);
+
+      expect(retryConfig.maxAttempts).toBe(5); // overridden
+      expect(retryConfig.baseDelay).toBe(500); // overridden
+      expect(retryConfig.maxDelay).toBe(30000); // from global
+      expect(retryConfig.exponentialBackoff).toBe(true); // from global
+      expect(retryConfig.retryableStatusCodes).toEqual([408, 429, 500, 502, 503, 504]); // from global
+    });
+
+    it("should handle partial retry overrides", () => {
+      const retryConfig = getRetryConfig("fast", globalConfig);
+
+      expect(retryConfig.maxAttempts).toBe(1); // overridden
+      expect(retryConfig.baseDelay).toBe(1000); // from global
+      expect(retryConfig.maxDelay).toBe(30000); // from global
+    });
+
+    it("should handle entity with no retry config", () => {
+      const retryConfig = getRetryConfig("undefined-entity", globalConfig);
+
+      expect(retryConfig).toEqual(globalConfig.retry);
+    });
+  });
 });

package/src/config.ts

@@ -8,12 +8,22 @@ export interface ParallelProcessingConfig {
   preserveRowOrder: boolean;
 }
 
+export interface RetryConfig {
+  maxAttempts: number;
+  baseDelay: number;
+  maxDelay: number;
+  exponentialBackoff: boolean;
+  retryableStatusCodes: number[];
+}
+
 export interface EntityConfig {
   concurrency?: number;
   preserveRowOrder?: boolean;
+  retry?: Partial<RetryConfig>;
 }
 
 export interface ProcessingConfig {
+  retry: RetryConfig;
   parallelProcessing: ParallelProcessingConfig;
   entityConfig: Record<string, EntityConfig>;
   entityDependencies: Record<string, string[]>;
@@ -23,6 +33,14 @@ export interface FullConfig extends ProcessingConfig {
   // Future: additional config sections can be added here
 }
 
+export const DEFAULT_RETRY_CONFIG: RetryConfig = {
+  maxAttempts: 3,
+  baseDelay: 1000,
+  maxDelay: 30000,
+  exponentialBackoff: true,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+};
+
 export const DEFAULT_PARALLEL_CONFIG: ParallelProcessingConfig = {
   concurrency: 1,
   entityConcurrency: 1,
@@ -30,6 +48,7 @@ export const DEFAULT_PARALLEL_CONFIG: ParallelProcessingConfig = {
 };
 
 export const DEFAULT_CONFIG: ProcessingConfig = {
+  retry: DEFAULT_RETRY_CONFIG,
   parallelProcessing: DEFAULT_PARALLEL_CONFIG,
   entityConfig: {},
   entityDependencies: {},
@@ -58,6 +77,10 @@ export function loadConfig(configDir: string): ProcessingConfig {
 
 function mergeWithDefaults(yamlConfig: Partial<FullConfig>): ProcessingConfig {
   return {
+    retry: {
+      ...DEFAULT_RETRY_CONFIG,
+      ...(yamlConfig.retry || {}),
+    },
     parallelProcessing: {
       ...DEFAULT_PARALLEL_CONFIG,
       ...(yamlConfig.parallelProcessing || {}),
@@ -88,3 +111,15 @@ export function getEntityConfig(
 
   return finalConfig;
 }
+
+export function getRetryConfig(
+  entityName: string,
+  globalConfig: ProcessingConfig
+): RetryConfig {
+  const entityOverrides = globalConfig.entityConfig[entityName]?.retry || {};
+
+  return {
+    ...globalConfig.retry,
+    ...entityOverrides,
+  };
+}

package/src/graphql-client.test.ts

@@ -63,7 +63,7 @@ describe("GraphQLClientWrapper", () => {
       clientWrapper.executeMutation(mutation, variables)
     ).rejects.toThrow("GraphQL error");
 
-    expect(consoleSpy).toHaveBeenCalledWith("GraphQL mutation failed:", error);
+    expect(consoleSpy).toHaveBeenCalledWith("GraphQL mutation failed after 3 attempts:", error);
 
     consoleSpy.mockRestore();
   });
@@ -75,4 +75,130 @@ describe("GraphQLClientWrapper", () => {
 
     expect(mockSetHeaders).toHaveBeenCalledWith(newHeaders);
   });
+
+  describe("retry functionality", () => {
+    it("should retry on retryable status codes", async () => {
+      const mutation = "mutation { createUser(name: $name) { id } }";
+      const variables = { name: "John" };
+      const retryConfig = {
+        maxAttempts: 3,
+        baseDelay: 100,
+        maxDelay: 1000,
+        exponentialBackoff: false,
+        retryableStatusCodes: [500],
+      };
+
+      const serverError = new Error("Server Error");
+      (serverError as any).response = { status: 500 };
+
+      mockRequest
+        .mockRejectedValueOnce(serverError)
+        .mockRejectedValueOnce(serverError)
+        .mockResolvedValueOnce({ data: { result: "success" } });
+
+      const result = await clientWrapper.executeMutation(mutation, variables, retryConfig);
+
+      expect(mockRequest).toHaveBeenCalledTimes(3);
+      expect(result).toEqual({ data: { result: "success" } });
+    });
+
+    it("should not retry on non-retryable status codes", async () => {
+      const mutation = "mutation { createUser(name: $name) { id } }";
+      const variables = { name: "John" };
+      const retryConfig = {
+        maxAttempts: 3,
+        baseDelay: 100,
+        maxDelay: 1000,
+        exponentialBackoff: false,
+        retryableStatusCodes: [500],
+      };
+
+      const clientError = new Error("Bad Request");
+      (clientError as any).response = { status: 400 };
+
+      mockRequest.mockRejectedValueOnce(clientError);
+
+      await expect(
+        clientWrapper.executeMutation(mutation, variables, retryConfig)
+      ).rejects.toThrow("Bad Request");
+
+      expect(mockRequest).toHaveBeenCalledTimes(1);
+    });
+
+    it("should retry on network errors (no response)", async () => {
+      const mutation = "mutation { createUser(name: $name) { id } }";
+      const variables = { name: "John" };
+      const retryConfig = {
+        maxAttempts: 2,
+        baseDelay: 100,
+        maxDelay: 1000,
+        exponentialBackoff: false,
+        retryableStatusCodes: [500],
+      };
+
+      const networkError = new Error("Network Error");
+      // No response property = network error
+
+      mockRequest
+        .mockRejectedValueOnce(networkError)
+        .mockResolvedValueOnce({ data: { result: "success" } });
+
+      const result = await clientWrapper.executeMutation(mutation, variables, retryConfig);
+
+      expect(mockRequest).toHaveBeenCalledTimes(2);
+      expect(result).toEqual({ data: { result: "success" } });
+    });
+
+    it("should fail after max attempts are exhausted", async () => {
+      const mutation = "mutation { createUser(name: $name) { id } }";
+      const variables = { name: "John" };
+      const retryConfig = {
+        maxAttempts: 2,
+        baseDelay: 100,
+        maxDelay: 1000,
+        exponentialBackoff: false,
+        retryableStatusCodes: [500],
+      };
+
+      const serverError = new Error("Server Error");
+      (serverError as any).response = { status: 500 };
+
+      mockRequest.mockRejectedValue(serverError);
+
+      await expect(
+        clientWrapper.executeMutation(mutation, variables, retryConfig)
+      ).rejects.toThrow("Server Error");
+
+      expect(mockRequest).toHaveBeenCalledTimes(2);
+    });
+
+    it("should use exponential backoff when configured", async () => {
+      const mutation = "mutation { createUser(name: $name) { id } }";
+      const variables = { name: "John" };
+      const retryConfig = {
+        maxAttempts: 3,
+        baseDelay: 100,
+        maxDelay: 1000,
+        exponentialBackoff: true,
+        retryableStatusCodes: [500],
+      };
+
+      const serverError = new Error("Server Error");
+      (serverError as any).response = { status: 500 };
+
+      mockRequest
+        .mockRejectedValueOnce(serverError)
+        .mockRejectedValueOnce(serverError)
+        .mockResolvedValueOnce({ data: { result: "success" } });
+
+      const startTime = Date.now();
+      const result = await clientWrapper.executeMutation(mutation, variables, retryConfig);
+      const totalTime = Date.now() - startTime;
+
+      expect(mockRequest).toHaveBeenCalledTimes(3);
+      expect(result).toEqual({ data: { result: "success" } });
+      // Should have some delay for retries (base + exponential)
+      expect(totalTime).toBeGreaterThan(200); // At least 100ms base + 200ms exponential
+    });
+  });
 });

package/src/graphql-client.ts

@@ -1,51 +1,151 @@
-import { GraphQLClient } from 'graphql-request';
-import { MetricsCollector } from './metrics';
+import { GraphQLClient } from "graphql-request";
+import { MetricsCollector } from "./metrics";
+import { DEFAULT_RETRY_CONFIG, RetryConfig } from "./config";
 
 export class GraphQLClientWrapper {
   private client: GraphQLClient;
   private metrics?: MetricsCollector;
   private verbose: boolean;
 
-  constructor(endpoint: string, headers?: Record<string, string>, metrics?: MetricsCollector, verbose: boolean = false) {
+  constructor(
+    endpoint: string,
+    headers?: Record<string, string>,
+    metrics?: MetricsCollector,
+    verbose: boolean = false
+  ) {
     this.client = new GraphQLClient(endpoint, {
-      headers: headers || {}
+      headers: headers || {},
     });
     this.metrics = metrics;
     this.verbose = verbose;
   }
 
-  async executeMutation(mutation: string, variables: Record<string, any>): Promise<any> {
-    const startTime = Date.now();
-    
-    try {
-      const result = await this.client.request(mutation, variables);
-      
-      if (this.metrics) {
-        const duration = Date.now() - startTime;
-        this.metrics.recordRequestDuration(duration);
-      }
-      
-      if (this.verbose) {
-        console.log(`✓ GraphQL request completed in ${Date.now() - startTime}ms:`, result);
-      }
-      
-      return result;
-    } catch (error) {
-      if (this.metrics) {
-        const duration = Date.now() - startTime;
-        this.metrics.recordRequestDuration(duration);
-      }
-      
-      if (this.verbose) {
-        console.error(`✗ GraphQL request failed in ${Date.now() - startTime}ms:`, error);
-      } else {
-        console.error('GraphQL mutation failed:', error);
+  async executeMutation(
+    mutation: string,
+    variables: Record<string, any>,
+    retryConfig?: RetryConfig
+  ): Promise<any> {
+    const config = retryConfig || DEFAULT_RETRY_CONFIG;
+
+    let lastError: any;
+    const totalStartTime = Date.now();
+
+    for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
+      const attemptStartTime = Date.now();
+
+      try {
+        const result = await this.client.request(mutation, variables);
+
+        if (this.metrics) {
+          const duration = Date.now() - attemptStartTime;
+          this.metrics.recordRequestDuration(duration);
+          if (attempt > 0) {
+            this.metrics.recordRetrySuccess(attempt);
+          }
+        }
+
+        if (this.verbose) {
+          const totalDuration = Date.now() - totalStartTime;
+          const retryInfo =
+            attempt > 0 ? ` (succeeded on attempt ${attempt + 1})` : "";
+          console.log(
+            `✓ GraphQL request completed in ${totalDuration}ms${retryInfo}:`,
+            result
+          );
+        }
+
+        return result;
+      } catch (error: any) {
+        lastError = error;
+        const duration = Date.now() - attemptStartTime;
+
+        if (this.metrics) {
+          this.metrics.recordRequestDuration(duration);
+        }
+
+        // Check if this is the last attempt
+        if (attempt === config.maxAttempts - 1) {
+          if (this.metrics && attempt > 0) {
+            this.metrics.recordRetryFailure(attempt);
+          }
+          break;
+        }
+
+        // Check if error is retryable
+        if (!this.isRetryableError(error, config)) {
+          if (this.verbose) {
+            console.error(
+              `✗ GraphQL request failed with non-retryable error in ${duration}ms:`,
+              error
+            );
+          } else {
+            console.error("GraphQL mutation failed (non-retryable):", error);
+          }
+          throw error;
+        }
+
+        // Calculate delay
+        const delay = this.calculateDelay(attempt, config);
+
+        if (this.verbose) {
+          console.log(
+            `⏳ GraphQL request failed (attempt ${attempt + 1}/${
+              config.maxAttempts
+            }), retrying in ${delay}ms...`
+          );
+        }
+
+        // Wait before retry
+        await this.sleep(delay);
       }
-      throw error;
     }
+
+    // All retries exhausted
+    if (this.verbose) {
+      const totalDuration = Date.now() - totalStartTime;
+      console.error(
+        `✗ GraphQL request failed after ${config.maxAttempts} attempts in ${totalDuration}ms:`,
+        lastError
+      );
+    } else {
+      console.error(
+        `GraphQL mutation failed after ${config.maxAttempts} attempts:`,
+        lastError
+      );
+    }
+
+    throw lastError;
+  }
+
+  private isRetryableError(error: any, config: RetryConfig): boolean {
+    // Network errors (no response)
+    if (!error.response) {
+      return true;
+    }
+
+    // Check HTTP status codes
+    const status = error.response.status;
+    return config.retryableStatusCodes.includes(status);
+  }
+
+  private calculateDelay(attempt: number, config: RetryConfig): number {
+    if (!config.exponentialBackoff) {
+      return config.baseDelay;
+    }
+
+    const exponentialDelay = config.baseDelay * Math.pow(2, attempt);
+    const cappedDelay = Math.min(exponentialDelay, config.maxDelay);
+
+    // Add jitter (±20% randomization)
+    const jitter = cappedDelay * 0.2 * (Math.random() - 0.5);
+    return Math.max(0, cappedDelay + jitter);
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
   setHeaders(headers: Record<string, string>) {
     this.client.setHeaders(headers);
   }
-}
+}