repzo 1.0.228 → 1.0.229

package/README.md

@@ -26,7 +26,21 @@ npm install repzo
 
 ```typescript
 import Repzo from "repzo";
+
+// Basic initialization
 const repzo = new Repzo("my-repzo-api-key");
+
+// With options (staging environment, custom timeout, retry logic)
+const repzoWithOptions = new Repzo("my-repzo-api-key", {
+  env: "staging", // 'production', 'staging', or 'local'
+  timeout: 60000, // Request timeout in milliseconds
+  retryAttempts: 3, // Number of retry attempts (default: 3)
+  headers: {
+    "Custom-Header": "value",
+  },
+});
+
+// Find clients
 let clients = repzo.client.find({ search: "Mecca" });
 
 // Example usage with type safety
@@ -39,6 +53,26 @@ const params: Service.Client.Find.Params = {
 // Your API implementation here
 ```
 
+### Retry Logic
+
+The SDK includes automatic retry logic for failed requests:
+
+- **Default Behavior**: Automatically retries failed requests up to 3 times
+- **Exponential Backoff**: Uses exponential backoff strategy (2^attempt seconds)
+- **401 Protection**: Never retries on 401 (Unauthorized) errors
+- **Configurable**: Set custom retry attempts via `retryAttempts` option
+
+```typescript
+// Default: 3 retry attempts
+const repzo = new Repzo("api-key");
+
+// Custom: 5 retry attempts
+const repzoCustom = new Repzo("api-key", { retryAttempts: 5 });
+
+// Disable retries: 1 attempt only
+const repzoNoRetry = new Repzo("api-key", { retryAttempts: 1 });
+```
+
 ## 📖 Documentation
 
 This SDK provides **three levels of documentation**:

package/changelog.md

@@ -4,6 +4,9 @@
 
 ### Added
 
+- add: Automatic retry logic for HTTP requests with exponential backoff (default: 3 attempts, configurable via `retryAttempts` option)
+- add: `retryAttempts` option to SDK constructor for configuring retry behavior @mkhamis
+- add: 401 error protection - authentication errors are never retried @mkhamis
 - add: asset-part-type, asset-part, asset-part-unit, asset-part-transfer, asset-part-receival, return-asset-part-unit & store-asset-part-unit @maramalshen
 - update adjustInventory @maramalshen
 - update FullInvoice with ubl keys @maramalshen
@@ -14,6 +17,8 @@
 
 ### Changed
 
+- All HTTP methods (\_fetch, \_create, \_update, \_patch, \_delete) now support automatic retry with exponential backoff @mkhamis
+
 ### Fixed
 
 ### Removed

package/lib/index.d.ts

@@ -123,6 +123,7 @@ export default class Repzo {
     private svAPIEndpoint;
     headers: Headers;
     private timeout;
+    private retryAttempts;
     constructor(apiKey: string, options?: Options);
     private static _end_points;
     static get END_POINTS(): {
@@ -242,6 +243,7 @@ export default class Repzo {
         readonly PROMOTIONS: "promotions";
         readonly COMPARE_INVOICE_TO_WAREHOUSE: "compare-invoice-to-warehouse";
     };
+    private _retryRequest;
     private _fetch;
     private _create;
     private _update;

package/lib/index.js

@@ -2338,52 +2338,83 @@ class Repzo {
         else {
             this.timeout = 180000;
         }
+        this.retryAttempts = options?.retryAttempts ?? 3;
     }
     static get END_POINTS() {
         return Repzo._end_points;
     }
-    async _fetch(baseUrl, path, params) {
-        if (params) {
-            params = normalizeParams(params);
+    async _retryRequest(requestFn, attempt = 1) {
+        try {
+            return await requestFn();
+        }
+        catch (error) {
+            // Don't retry on 401 (Unauthorized) errors
+            if (error?.response?.status === 401) {
+                throw error;
+            }
+            // Retry if we haven't exceeded the retry attempts
+            if (attempt < this.retryAttempts) {
+                // Exponential backoff: wait 2^attempt seconds before retrying
+                const delay = Math.pow(2, attempt) * 1000;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return this._retryRequest(requestFn, attempt + 1);
+            }
+            // If all retries failed, throw the error
+            throw error;
         }
-        let res = await axios.get(`${baseUrl}/${path}`, {
-            params,
-            headers: this.headers,
-            timeout: this.timeout,
+    }
+    async _fetch(baseUrl, path, params) {
+        return this._retryRequest(async () => {
+            if (params) {
+                params = normalizeParams(params);
+            }
+            let res = await axios.get(`${baseUrl}/${path}`, {
+                params,
+                headers: this.headers,
+                timeout: this.timeout,
+            });
+            return res.data;
         });
-        return res.data;
     }
     async _create(baseUrl, path, body, params) {
-        let res = await axios.post(`${baseUrl}/${path}`, body, {
-            params,
-            headers: this.headers,
-            timeout: this.timeout,
+        return this._retryRequest(async () => {
+            let res = await axios.post(`${baseUrl}/${path}`, body, {
+                params,
+                headers: this.headers,
+                timeout: this.timeout,
+            });
+            return res.data;
         });
-        return res.data;
     }
     async _update(baseUrl, path, body, params) {
-        let res = await axios.put(`${baseUrl}/${path}`, body, {
-            params,
-            headers: this.headers,
-            timeout: this.timeout,
+        return this._retryRequest(async () => {
+            let res = await axios.put(`${baseUrl}/${path}`, body, {
+                params,
+                headers: this.headers,
+                timeout: this.timeout,
+            });
+            return res.data;
         });
-        return res.data;
     }
     async _patch(baseUrl, path, body, params) {
-        let res = await axios.put(`${baseUrl}/${path}`, body, {
-            params,
-            headers: this.headers,
-            timeout: this.timeout,
+        return this._retryRequest(async () => {
+            let res = await axios.put(`${baseUrl}/${path}`, body, {
+                params,
+                headers: this.headers,
+                timeout: this.timeout,
+            });
+            return res.data;
         });
-        return res.data;
     }
     async _delete(baseUrl, path, params) {
-        let res = await axios.delete(`${baseUrl}/${path}`, {
-            params,
-            headers: this.headers,
-            timeout: this.timeout,
+        return this._retryRequest(async () => {
+            let res = await axios.delete(`${baseUrl}/${path}`, {
+                params,
+                headers: this.headers,
+                timeout: this.timeout,
+            });
+            return res.data;
         });
-        return res.data;
     }
 }
 Repzo._end_points = end_points;

package/lib/types/index.d.ts

@@ -12,6 +12,7 @@ export interface Options {
         [key: string]: string;
     };
     timeout?: number | undefined;
+    retryAttempts?: number;
 }
 export interface Headers {
     "api-key": string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repzo",
-  "version": "1.0.228",
+  "version": "1.0.229",
   "description": "Repzo TypeScript SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/src/index.ts

@@ -230,6 +230,7 @@ export default class Repzo {
   private svAPIEndpoint: string;
   headers: Headers;
   private timeout: number;
+  private retryAttempts: number;
   constructor(apiKey: string, options?: Options) {
     this.svAPIEndpoint =
       !options?.env || options?.env == "production"
@@ -251,22 +252,51 @@ export default class Repzo {
     } else {
       this.timeout = 180000;
     }
+    this.retryAttempts = options?.retryAttempts ?? 3;
   }
 
   private static _end_points = end_points;
   public static get END_POINTS() {
     return Repzo._end_points;
   }
-  private async _fetch(baseUrl: string, path: string, params?: Params) {
-    if (params) {
-      params = normalizeParams(params);
+
+  private async _retryRequest<T>(
+    requestFn: () => Promise<T>,
+    attempt: number = 1,
+  ): Promise<T> {
+    try {
+      return await requestFn();
+    } catch (error: any) {
+      // Don't retry on 401 (Unauthorized) errors
+      if (error?.response?.status === 401) {
+        throw error;
+      }
+
+      // Retry if we haven't exceeded the retry attempts
+      if (attempt < this.retryAttempts) {
+        // Exponential backoff: wait 2^attempt seconds before retrying
+        const delay = Math.pow(2, attempt) * 1000;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this._retryRequest(requestFn, attempt + 1);
+      }
+
+      // If all retries failed, throw the error
+      throw error;
     }
-    let res: any = await axios.get(`${baseUrl}/${path}`, {
-      params,
-      headers: this.headers,
-      timeout: this.timeout,
+  }
+
+  private async _fetch(baseUrl: string, path: string, params?: Params) {
+    return this._retryRequest(async () => {
+      if (params) {
+        params = normalizeParams(params);
+      }
+      let res: any = await axios.get(`${baseUrl}/${path}`, {
+        params,
+        headers: this.headers,
+        timeout: this.timeout,
+      });
+      return res.data;
     });
-    return res.data;
   }
 
   private async _create(
@@ -275,12 +305,14 @@ export default class Repzo {
     body: Data,
     params?: Params,
   ) {
-    let res: any = await axios.post(`${baseUrl}/${path}`, body, {
-      params,
-      headers: this.headers,
-      timeout: this.timeout,
+    return this._retryRequest(async () => {
+      let res: any = await axios.post(`${baseUrl}/${path}`, body, {
+        params,
+        headers: this.headers,
+        timeout: this.timeout,
+      });
+      return res.data;
     });
-    return res.data;
   }
 
   private async _update(
@@ -289,12 +321,14 @@ export default class Repzo {
     body: Data,
     params?: Params,
   ) {
-    let res: any = await axios.put(`${baseUrl}/${path}`, body, {
-      params,
-      headers: this.headers,
-      timeout: this.timeout,
+    return this._retryRequest(async () => {
+      let res: any = await axios.put(`${baseUrl}/${path}`, body, {
+        params,
+        headers: this.headers,
+        timeout: this.timeout,
+      });
+      return res.data;
     });
-    return res.data;
   }
 
   private async _patch(
@@ -303,21 +337,25 @@ export default class Repzo {
     body: Data,
     params?: Params,
   ) {
-    let res: any = await axios.put(`${baseUrl}/${path}`, body, {
-      params,
-      headers: this.headers,
-      timeout: this.timeout,
+    return this._retryRequest(async () => {
+      let res: any = await axios.put(`${baseUrl}/${path}`, body, {
+        params,
+        headers: this.headers,
+        timeout: this.timeout,
+      });
+      return res.data;
     });
-    return res.data;
   }
 
   private async _delete(baseUrl: string, path: string, params?: Params) {
-    let res: any = await axios.delete(`${baseUrl}/${path}`, {
-      params,
-      headers: this.headers,
-      timeout: this.timeout,
+    return this._retryRequest(async () => {
+      let res: any = await axios.delete(`${baseUrl}/${path}`, {
+        params,
+        headers: this.headers,
+        timeout: this.timeout,
+      });
+      return res.data;
     });
-    return res.data;
   }
 
   available_services = availableService;

package/src/types/index.ts

@@ -11,6 +11,7 @@ export interface Options {
   env?: "staging" | "local" | "production";
   headers?: { [key: string]: string };
   timeout?: number | undefined;
+  retryAttempts?: number;
 }
 export interface Headers {
   "api-key": string;