@rendomnet/apiservice 1.0.0 → 1.3.1

package/README.md

@@ -8,6 +8,8 @@ A robust TypeScript API service framework for making authenticated API calls wit
 - ✅ Status code-specific hooks for handling errors
 - ✅ Account state tracking
 - ✅ File upload support
+- ✅ Support for multiple accounts or a single default account
+- ✅ Automatic token refresh for 401 errors
 
 ## Usage
 
@@ -17,29 +19,353 @@ import ApiService from 'apiservice';
 // Create and setup the API service
 const api = new ApiService();
 api.setup({
-  provider: 'my-service',
+  provider: 'my-service', // 'google' | 'microsoft' and etc.
   tokenService: myTokenService,
   hooks: {
-    401: {
-      retryCall: true,
-      retryDelay: true,
-      callback: async (accountId, response) => {
-        // Handle token refresh logic
-        return { /* updated parameters */ };
-      }
-    }
+    // You can define custom hooks here,
+    // or use the default token refresh handler for 401 errors
   },
-  cacheTime: 30000 // 30 seconds
+  cacheTime: 30000, // 30 seconds
+  baseUrl: 'https://api.example.com' // Set default base URL
 });
 
-// Make API calls
-const result = await api.makeApiCall({
+// Make API calls with specific account ID and use default baseUrl
+const result = await api.call({
   accountId: 'user123',
   method: 'GET',
-  base: 'https://api.example.com',
   route: '/users',
-  requireAuth: true
+  useAuth: true
+});
+
+// Override default baseUrl for specific calls
+const customResult = await api.call({
+  method: 'GET',
+  base: 'https://api2.example.com', // Override default baseUrl
+  route: '/users',
+  useAuth: true
+});
+
+// Or omit accountId to use the default account ('default')
+const defaultResult = await api.call({
+  method: 'GET',
+  route: '/users',
+  useAuth: true
+});
+```
+
+## Automatic Token Refresh
+
+ApiService includes a built-in handler for 401 (Unauthorized) errors that automatically refreshes OAuth tokens. This feature:
+
+1. Detects 401 errors from the API
+2. Retrieves the current token for the account
+3. Uses the `refresh` method from your tokenService to obtain a new token
+4. Updates the stored token with the new one
+5. Retries the original API request with the new token
+
+To use this feature:
+
+1. Ensure your tokenService implements the `refresh` method
+2. Don't specify a custom 401 hook (the default will be used automatically)
+
+```typescript
+// Example token service with refresh capability
+const tokenService = {
+  async get(accountId = 'default') {
+    // Get token from storage
+    return storedToken;
+  },
+  
+  async set(token, accountId = 'default') {
+    // Save token to storage
+  },
+  
+  async refresh(refreshToken, accountId = 'default') {
+    // Refresh the token with your OAuth provider
+    const response = await fetch('https://api.example.com/oauth/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        client_id: 'your-client-id'
+      })
+    });
+    
+    if (!response.ok) {
+      throw new Error('Failed to refresh token');
+    }
+    
+    return await response.json();
+  }
+};
+```
+
+If you prefer to handle token refresh yourself, you can either:
+
+1. Provide your own handler for 401 errors which will override the default
+2. Disable the default handler by setting `hooks: { 401: null }`
+
+```typescript
+// Disable default 401 handler without providing a custom one
+api.setup({
+  provider: 'my-service',
+  tokenService,
+  hooks: {
+    401: null // Explicitly disable the default handler
+  },
+  cacheTime: 30000
+});
+```
+
+## Account Management
+
+ApiService supports multiple accounts through the `accountId` parameter. This allows you to:
+
+1. **Manage multiple tokens** - Maintain separate authentication tokens for different users or services
+2. **Track state by account** - Each account has its own state tracking (request times, failures)
+3. **Apply account-specific retry logic** - Hooks can behave differently based on the account
+
+For simple applications that only need a single account, you can omit the accountId parameter:
+
+```typescript
+// Make calls without specifying accountId - uses 'default' automatically
+const result = await api.call({
+  method: 'GET',
+  route: '/users'
+});
+```
+
+If no accountId is provided, ApiService automatically uses 'default' as the account ID.
+
+## Token Service
+
+ApiService requires a `tokenService` for authentication. This service manages tokens for different accounts and handles token retrieval, storage, and refresh operations.
+
+### TokenService Interface
+
+```typescript
+interface TokenService {
+  // Get a token for an account (accountId is optional, defaults to 'default')
+  get: (accountId?: string) => Promise<Token>;
+  
+  // Save a token for an account
+  set: (token: Partial<Token>, accountId?: string) => Promise<void>;
+  
+  // Optional: Refresh an expired token
+  refresh?: (refreshToken: string, accountId?: string) => Promise<OAuthToken>;
+}
+
+// The Token interface
+interface Token {
+  accountId: string;
+  access_token: string;
+  refresh_token: string;
+  provider: string;
+  enabled?: boolean;
+  updatedAt?: string;
+  primary?: boolean;
+}
+
+// OAuth token response
+interface OAuthToken {
+  access_token: string;
+  expires_in: number;
+  id_token: string;
+  refresh_token: string;
+  scope: string;
+  token_type: string;
+}
+```
+
+### Example Implementation
+
+Here's a simple `tokenService` implementation using localStorage:
+
+```typescript
+// Simple token service implementation
+const tokenService = {
+  // Get token for an account
+  async get(accountId = 'default'): Promise<Token> {
+    const storedToken = localStorage.getItem(`token-${accountId}`);
+    if (!storedToken) {
+      throw new Error(`No token found for account ${accountId}`);
+    }
+    return JSON.parse(storedToken);
+  },
+  
+  // Save token for an account
+  async set(token: Partial<Token>, accountId = 'default'): Promise<void> {
+    const existingToken = localStorage.getItem(`token-${accountId}`);
+    const currentToken = existingToken ? JSON.parse(existingToken) : { accountId };
+    const updatedToken = { ...currentToken, ...token, updatedAt: new Date().toISOString() };
+    localStorage.setItem(`token-${accountId}`, JSON.stringify(updatedToken));
+  },
+  
+  // Refresh token implementation
+  async refresh(refreshToken: string, accountId = 'default'): Promise<OAuthToken> {
+    // Make a request to your OAuth token endpoint
+    const response = await fetch('https://api.example.com/oauth/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        client_id: 'your-client-id'
+      })
+    });
+    
+    if (!response.ok) {
+      throw new Error('Failed to refresh token');
+    }
+    
+    const newToken = await response.json();
+    
+    // Update the stored token
+    await this.set({
+      access_token: newToken.access_token,
+      refresh_token: newToken.refresh_token
+    }, accountId);
+    
+    return newToken;
+  }
+};
+```
+
+### Complete Authorization Flow Example
+
+Here's a complete example showing how to use ApiService with automatic token refresh:
+
+```typescript
+import ApiService from 'apiservice';
+
+// Create token service with refresh capability
+const tokenService = {
+  // Get token from storage
+  async get(accountId = 'default') {
+    const storedToken = localStorage.getItem(`token-${accountId}`);
+    if (!storedToken) {
+      throw new Error(`No token found for account ${accountId}`);
+    }
+    return JSON.parse(storedToken);
+  },
+  
+  // Save token to storage
+  async set(token, accountId = 'default') {
+    const existingToken = localStorage.getItem(`token-${accountId}`);
+    const currentToken = existingToken ? JSON.parse(existingToken) : { accountId };
+    const updatedToken = { ...currentToken, ...token, updatedAt: new Date().toISOString() };
+    localStorage.setItem(`token-${accountId}`, JSON.stringify(updatedToken));
+  },
+  
+  // Refresh token with OAuth provider
+  async refresh(refreshToken, accountId = 'default') {
+    // Real implementation would call your OAuth endpoint
+    const response = await fetch('https://api.example.com/oauth/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        client_id: 'your-client-id'
+      })
+    });
+    
+    if (!response.ok) {
+      throw new Error('Failed to refresh token');
+    }
+    
+    return await response.json();
+  }
+};
+
+// Create API service instance
+const api = new ApiService();
+
+// Configure API service with automatic token refresh
+api.setup({
+  provider: 'example-api',
+  tokenService,
+  cacheTime: 30000,
+  baseUrl: 'https://api.example.com',
+  
+  // You can still add custom hooks for other status codes
+  // The default 401 handler will be used automatically
+  hooks: {
+    // Handle 403 Forbidden errors - typically for insufficient permissions
+    403: {
+      shouldRetry: false,
+      handler: async (accountId, response) => {
+        console.warn('Permission denied:', response);
+        // You could trigger a permissions UI here
+        window.dispatchEvent(new CustomEvent('permission:required', { 
+          detail: { accountId, resource: response.resource } 
+        }));
+        return null;
+      }
+    }
+  }
 });
+
+// Use the API service
+async function fetchUserData(userId) {
+  try {
+    return await api.call({
+      // No accountId needed - will use 'default' automatically
+      method: 'GET',
+      route: `/users/${userId}`,
+      useAuth: true
+    });
+  } catch (error) {
+    // 401 errors with valid refresh tokens will be automatically handled
+    // This catch will only trigger for other errors or if refresh fails
+    console.error('Failed to fetch user data:', error);
+    throw error;
+  }
+}
+```
+
+## Hook Options
+
+Hooks can be configured to handle specific HTTP status codes:
+
+```typescript
+const hooks = {
+  401: {
+    // Core settings
+    shouldRetry: true,           // Whether to retry the API call when this hook is triggered
+    useRetryDelay: true,         // Whether to apply delay between retries
+    maxRetries: 3,               // Maximum number of retry attempts for this status code (default: 4)
+    
+    // Advanced options
+    preventConcurrentCalls: true, // Wait for an existing hook to complete before starting a new one
+                                  // Useful for avoiding duplicate refresh token calls
+    
+    // Handler functions
+    handler: async (accountId, response) => {
+      // Main handler function called when this status code is encountered
+      // Return an object to update the API call parameters for the retry
+      return { /* updated parameters */ };
+    },
+    
+    onMaxRetriesExceeded: async (accountId, error) => {
+      // Called when all retry attempts for this status code have failed
+    },
+    
+    onHandlerError: async (accountId, error) => {
+      // Called when the handler function throws an error
+    },
+    
+    // Delay strategy settings
+    delayStrategy: {
+      calculate: (attempt, response) => {
+        // Custom strategy for calculating delay between retries
+        return 1000 * Math.pow(2, attempt - 1); // Exponential backoff
+      }
+    },
+    maxDelay: 30000 // Maximum delay in milliseconds between retries (default: 60000)
+  }
+}
 ```
 
 ## Architecture
@@ -50,4 +376,55 @@ The codebase is built around a main `ApiService` class that coordinates several
 - `CacheManager`: Implements data caching with customizable expiration times
 - `RetryManager`: Manages retry logic with exponential backoff and other delay strategies
 - `HookManager`: Provides a way to hook into specific status codes and handle them
-- `AccountManager`: Tracks account state and handles account-specific data 
+- `AccountManager`: Tracks account state and handles account-specific data
+
+## Advanced Usage
+
+### Multiple API Providers
+
+```javascript
+// Configure multiple API providers
+api.setup({
+  provider: 'primary-api',
+  tokenService: primaryTokenService,
+  cacheTime: 30000,
+  baseUrl: 'https://api.primary.com'
+});
+
+api.setup({
+  provider: 'secondary-api',
+  tokenService: secondaryTokenService,
+  cacheTime: 60000,
+  baseUrl: 'https://api.secondary.com'
+});
+
+// Use different providers in API calls
+async function fetchCombinedData() {
+  const [primaryData, secondaryData] = await Promise.all([
+    api.call({
+      provider: 'primary-api',
+      method: 'GET',
+      route: '/data',
+      useAuth: true
+    }),
+    
+    api.call({
+      provider: 'secondary-api',
+      method: 'GET',
+      route: '/data',
+      useAuth: true
+    }),
+    
+    // Override baseUrl for a specific API call
+    api.call({
+      provider: 'primary-api',
+      method: 'GET',
+      route: '/special-data',
+      useAuth: true,
+      base: 'https://special-api.primary.com'
+    })
+  ]);
+  
+  return { primaryData, secondaryData };
+}
+```

package/dist/AccountManager.d.ts

@@ -4,24 +4,25 @@ import { AccountData } from './types';
  */
 export declare class AccountManager {
     private accounts;
+    private readonly DEFAULT_ACCOUNT;
     /**
      * Update account data for a specific account
      */
-    updateAccountData(accountId: string, data: Partial<AccountData>): void;
+    updateAccountData(accountId: string | undefined, data: Partial<AccountData>): void;
     /**
      * Get account data for a specific account
      */
-    getAccountData(accountId: string): AccountData;
+    getAccountData(accountId?: string): AccountData;
     /**
      * Check if an account's last request failed
      */
-    didLastRequestFail(accountId: string): boolean;
+    didLastRequestFail(accountId?: string): boolean;
     /**
      * Set account's last request as failed
      */
-    setLastRequestFailed(accountId: string, failed?: boolean): void;
+    setLastRequestFailed(accountId?: string, failed?: boolean): void;
     /**
      * Update the last request time for an account
      */
-    updateLastRequestTime(accountId: string): void;
+    updateLastRequestTime(accountId?: string): void;
 }

package/dist/AccountManager.js

@@ -7,11 +7,12 @@ exports.AccountManager = void 0;
 class AccountManager {
     constructor() {
         this.accounts = {};
+        this.DEFAULT_ACCOUNT = 'default';
     }
     /**
      * Update account data for a specific account
      */
-    updateAccountData(accountId, data) {
+    updateAccountData(accountId = this.DEFAULT_ACCOUNT, data) {
         this.accounts[accountId] = {
             ...this.accounts[accountId],
             ...data
@@ -20,26 +21,26 @@ class AccountManager {
     /**
      * Get account data for a specific account
      */
-    getAccountData(accountId) {
+    getAccountData(accountId = this.DEFAULT_ACCOUNT) {
         return this.accounts[accountId] || {};
     }
     /**
      * Check if an account's last request failed
      */
-    didLastRequestFail(accountId) {
+    didLastRequestFail(accountId = this.DEFAULT_ACCOUNT) {
         var _a;
         return !!((_a = this.accounts[accountId]) === null || _a === void 0 ? void 0 : _a.lastFailed);
     }
     /**
      * Set account's last request as failed
      */
-    setLastRequestFailed(accountId, failed = true) {
+    setLastRequestFailed(accountId = this.DEFAULT_ACCOUNT, failed = true) {
         this.updateAccountData(accountId, { lastFailed: failed });
     }
     /**
      * Update the last request time for an account
      */
-    updateLastRequestTime(accountId) {
+    updateLastRequestTime(accountId = this.DEFAULT_ACCOUNT) {
         this.updateAccountData(accountId, { lastRequestTime: Date.now() });
     }
 }

package/dist/HookManager.js

@@ -26,26 +26,26 @@ class HookManager {
      */
     async processHook(accountId, status, error) {
         const hook = this.hooks[status];
-        if (!hook || !hook.callback)
+        if (!hook || !hook.handler)
             return null;
-        const hookKey = `${accountId}-${status}`;
+        const hookKey = `${accountId || 'default'}-${status}`;
         try {
             // Handle waiting for existing hook call if needed
-            if (hook.waitUntilFinished) {
+            if (hook.preventConcurrentCalls) {
                 if (!this.hookPromises[hookKey]) {
-                    this.hookPromises[hookKey] = Promise.resolve(hook.callback(accountId, error.response) || {});
+                    this.hookPromises[hookKey] = Promise.resolve(hook.handler(accountId, error.response) || {});
                 }
                 const result = await this.hookPromises[hookKey];
                 delete this.hookPromises[hookKey];
                 return result;
             }
             // Otherwise just call the hook directly
-            return await hook.callback(accountId, error.response) || {};
+            return await hook.handler(accountId, error.response) || {};
         }
         catch (hookError) {
-            console.error(`Hook callback failed for status ${status}:`, hookError);
-            if (hook.errorCallback) {
-                await hook.errorCallback(accountId, hookError);
+            console.error(`Hook handler failed for status ${status}:`, hookError);
+            if (hook.onHandlerError) {
+                await hook.onHandlerError(accountId, hookError);
             }
             throw hookError;
         }
@@ -55,8 +55,8 @@ class HookManager {
      */
     async handleRetryFailure(accountId, status, error) {
         const hook = this.hooks[status];
-        if (hook === null || hook === void 0 ? void 0 : hook.onRetryFail) {
-            await hook.onRetryFail(accountId, error);
+        if (hook === null || hook === void 0 ? void 0 : hook.onMaxRetriesExceeded) {
+            await hook.onMaxRetriesExceeded(accountId, error);
         }
     }
     /**
@@ -64,7 +64,7 @@ class HookManager {
      */
     shouldRetry(status) {
         const hook = this.hooks[status];
-        return !!hook && !!hook.retryCall;
+        return !!hook && !!hook.shouldRetry;
     }
 }
 exports.HookManager = HookManager;

package/dist/HttpClient.js

@@ -15,7 +15,7 @@ class HttpClient {
      * Make an HTTP request
      */
     async makeRequest(apiParams, authToken) {
-        const { accountId, method, route, base, body, data, headers, queryParams, contentType = 'application/json', accessToken: forcedAccessToken, requireAuth = true, files, } = apiParams;
+        const { accountId, method, route, base, body, data, headers, queryParams, contentType = 'application/json', accessToken: forcedAccessToken, useAuth = true, files, } = apiParams;
         // Build URL and request body
         const url = this.buildUrl(base, route, queryParams);
         const requestBody = body || data;
@@ -30,7 +30,7 @@ class HttpClient {
             contentType,
             authToken,
             forcedAccessToken,
-            requireAuth,
+            useAuth,
             headers,
         });
         // Make the request
@@ -48,7 +48,8 @@ class HttpClient {
      * Build URL with query parameters
      */
     buildUrl(base, route, queryParams) {
-        let url = `${base}${route || ''}`;
+        const baseUrl = base || '';
+        let url = `${baseUrl}${route || ''}`;
         if (queryParams)
             url += `?${qs_1.default.stringify(queryParams)}`;
         return url;
@@ -70,12 +71,12 @@ class HttpClient {
     /**
      * Build fetch options for request
      */
-    buildFetchOptions({ method, body, formData, contentType, authToken, forcedAccessToken, requireAuth, headers, }) {
+    buildFetchOptions({ method, body, formData, contentType, authToken, forcedAccessToken, useAuth, headers, }) {
         const allowedMethods = ['POST', 'PUT', 'PATCH'];
         return {
             method,
             headers: {
-                ...(requireAuth && {
+                ...(useAuth && {
                     Authorization: `Bearer ${forcedAccessToken || authToken.access_token}`
                 }),
                 ...(!formData && { 'content-type': contentType }),

package/dist/index.d.ts

@@ -6,6 +6,7 @@ import { TokenService, ApiCallParams, HookSettings, StatusCode } from './types';
 declare class ApiService {
     provider: string;
     private tokenService;
+    private baseUrl;
     private cacheManager;
     private retryManager;
     private hookManager;
@@ -16,12 +17,18 @@ declare class ApiService {
     /**
      * Setup the API service
      */
-    setup({ provider, tokenService, hooks, cacheTime, }: {
+    setup({ provider, tokenService, hooks, cacheTime, baseUrl, }: {
         provider: string;
         tokenService: TokenService;
-        hooks?: Record<StatusCode, HookSettings>;
+        hooks?: Record<StatusCode, HookSettings | null>;
         cacheTime: number;
+        baseUrl?: string;
     }): void;
+    /**
+     * Create a default handler for 401 (Unauthorized) errors
+     * that implements standard token refresh behavior
+     */
+    private createDefaultTokenRefreshHandler;
     /**
      * Set the maximum number of retry attempts
      */
@@ -31,9 +38,18 @@ declare class ApiService {
      */
     updateAccountData(accountId: string, data: Partial<Record<string, any>>): void;
     /**
-     * Main API call method
+     * Make an API call with all features (caching, retry, hooks)
+     */
+    call(apiCallParams: Omit<ApiCallParams, 'accountId'> & {
+        accountId?: string;
+    }): Promise<any>;
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use call() instead
      */
-    makeApiCall(apiCallParams: ApiCallParams): Promise<any>;
+    makeApiCall(apiCallParams: Omit<ApiCallParams, 'accountId'> & {
+        accountId?: string;
+    }): Promise<any>;
     /**
      * Make a request with retry capability
      */

package/dist/index.js

@@ -7,6 +7,7 @@ const components_1 = require("./components");
  */
 class ApiService {
     constructor() {
+        this.baseUrl = ''; // Default base URL
         // Default max attempts for API calls
         this.maxAttempts = 10;
         this.provider = '';
@@ -21,16 +22,73 @@ class ApiService {
     /**
      * Setup the API service
      */
-    setup({ provider, tokenService, hooks, cacheTime, }) {
+    setup({ provider, tokenService, hooks = {}, cacheTime, baseUrl = '', }) {
         this.provider = provider;
         this.tokenService = tokenService;
-        if (hooks) {
-            this.hookManager.setHooks(hooks);
+        this.baseUrl = baseUrl;
+        // Create a copy of hooks to avoid modifying the input
+        const finalHooks = {};
+        // Apply default 401 handler if:
+        // 1. No 401 hook is explicitly defined (or is explicitly null)
+        // 2. TokenService has a refresh method
+        if (hooks[401] === undefined && typeof this.tokenService.refresh === 'function') {
+            finalHooks[401] = this.createDefaultTokenRefreshHandler();
+        }
+        // Add user-defined hooks (skipping null/undefined values)
+        for (const [statusCode, hook] of Object.entries(hooks)) {
+            if (hook) {
+                finalHooks[statusCode] = hook;
+            }
+        }
+        // Set the hooks if we have any
+        if (Object.keys(finalHooks).length > 0) {
+            this.hookManager.setHooks(finalHooks);
         }
         if (typeof cacheTime !== 'undefined') {
             this.cacheManager.setCacheTime(cacheTime);
         }
     }
+    /**
+     * Create a default handler for 401 (Unauthorized) errors
+     * that implements standard token refresh behavior
+     */
+    createDefaultTokenRefreshHandler() {
+        return {
+            shouldRetry: true,
+            useRetryDelay: true,
+            preventConcurrentCalls: true,
+            maxRetries: 1,
+            handler: async (accountId) => {
+                try {
+                    console.log(`🔄 Using default token refresh handler for ${accountId}`);
+                    // Get current token to extract refresh token
+                    const currentToken = await this.tokenService.get(accountId);
+                    if (!currentToken.refresh_token) {
+                        throw new Error(`No refresh token available for account ${accountId}`);
+                    }
+                    // Refresh the token
+                    const newToken = await this.tokenService.refresh(currentToken.refresh_token, accountId);
+                    if (!newToken || !newToken.access_token) {
+                        throw new Error('Token refresh returned invalid data');
+                    }
+                    // Update the token in storage
+                    await this.tokenService.set({
+                        access_token: newToken.access_token,
+                        refresh_token: newToken.refresh_token || currentToken.refresh_token
+                    }, accountId);
+                    // Return empty object to retry with same parameters
+                    return {};
+                }
+                catch (error) {
+                    console.error(`Token refresh failed for ${accountId}:`, error);
+                    throw error;
+                }
+            },
+            onMaxRetriesExceeded: async (accountId, error) => {
+                console.error(`Authentication failed after refresh attempt for ${accountId}:`, error);
+            }
+        };
+    }
     /**
      * Set the maximum number of retry attempts
      */
@@ -44,20 +102,34 @@ class ApiService {
         this.accountManager.updateAccountData(accountId, data);
     }
     /**
-     * Main API call method
+     * Make an API call with all features (caching, retry, hooks)
      */
-    async makeApiCall(apiCallParams) {
-        console.log('🔄 makeApiCall', this.provider, apiCallParams.accountId);
+    async call(apiCallParams) {
+        // Use 'default' as fallback if accountId is not provided
+        // and use default baseUrl if not provided
+        const params = {
+            ...apiCallParams,
+            accountId: apiCallParams.accountId || 'default',
+            base: apiCallParams.base || this.baseUrl,
+        };
+        console.log('🔄 API call', this.provider, params.accountId, params.method, params.route);
         // Check cache first
-        const cachedData = this.cacheManager.getFromCache(apiCallParams);
+        const cachedData = this.cacheManager.getFromCache(params);
         if (cachedData)
             return cachedData;
         // Make the API call with retry capability
-        const result = await this.makeRequestWithRetry(apiCallParams);
+        const result = await this.makeRequestWithRetry(params);
         // Cache the result
-        this.cacheManager.saveToCache(apiCallParams, result);
+        this.cacheManager.saveToCache(params, result);
         return result;
     }
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use call() instead
+     */
+    async makeApiCall(apiCallParams) {
+        return this.call(apiCallParams);
+    }
     /**
      * Make a request with retry capability
      */
@@ -73,11 +145,11 @@ class ApiService {
             attempts++;
             try {
                 // Get authentication token if needed
-                const authToken = apiCallParams.requireAuth !== false
+                const authToken = apiCallParams.useAuth !== false
                     ? await this.tokenService.get(accountId)
                     : {};
                 // Verify we have authentication if required
-                if (apiCallParams.requireAuth !== false && !apiCallParams.accessToken && !authToken.access_token) {
+                if (apiCallParams.useAuth !== false && !apiCallParams.accessToken && !authToken.access_token) {
                     throw new Error(`${this.provider} credentials not found for account ID ${accountId}`);
                 }
                 // Make the actual API call
@@ -114,7 +186,7 @@ class ApiService {
                     throw hookError;
                 }
                 // Wait before retrying if needed
-                if (activeHook === null || activeHook === void 0 ? void 0 : activeHook.retryDelay) {
+                if (activeHook === null || activeHook === void 0 ? void 0 : activeHook.useRetryDelay) {
                     await this.retryManager.calculateAndDelay({
                         attempt: statusRetries[status],
                         response: error.response,

package/dist/types.d.ts

@@ -27,33 +27,62 @@ interface ApiCallParams {
     accountId: string;
     method: 'GET' | 'POST' | 'PUT' | 'DELETE';
     route: string;
-    base: string;
+    base?: string;
     body?: object;
     data?: object;
     headers?: Record<string, string>;
     queryParams?: URLSearchParams;
     accessToken?: string;
-    requireAuth?: boolean;
+    useAuth?: boolean;
     noContentType?: boolean;
     contentType?: string;
     cacheTime?: number;
     files?: File[];
 }
 interface HookSettings {
-    retryCall: boolean;
-    retryDelay: boolean;
-    waitUntilFinished?: boolean;
+    /**
+     * Whether to retry the API call when this hook is triggered
+     */
+    shouldRetry: boolean;
+    /**
+     * Whether to apply delay between retries
+     */
+    useRetryDelay: boolean;
+    /**
+     * The maximum number of retry attempts for this status code
+     */
     maxRetries?: number;
-    callback: (accountId: string, response: any) => Promise<any>;
-    onRetryFail?: (accountId: string, error: any) => Promise<void>;
-    errorCallback?: (accountId: string, error: any) => Promise<void>;
+    /**
+     * Wait for an existing hook to complete before starting a new one
+     * Useful for avoiding duplicate refresh token calls
+     */
+    preventConcurrentCalls?: boolean;
+    /**
+     * The main handler function called when this status code is encountered
+     * Return an object to update the API call parameters for the retry
+     */
+    handler: (accountId: string, response: any) => Promise<any>;
+    /**
+     * Called when all retry attempts for this status code have failed
+     */
+    onMaxRetriesExceeded?: (accountId: string, error: any) => Promise<void>;
+    /**
+     * Called when the handler function throws an error
+     */
+    onHandlerError?: (accountId: string, error: any) => Promise<void>;
+    /**
+     * Custom strategy for calculating delay between retries
+     */
     delayStrategy?: DelayStrategy;
+    /**
+     * Maximum delay in milliseconds between retries
+     */
     maxDelay?: number;
 }
 type StatusCode = string | number;
 type TokenService = {
-    get: (accountId: string) => Promise<Token>;
-    set: (accountId: string, token: Partial<Token>) => Promise<void>;
-    refresh?: (accountId: string, refreshToken: string) => Promise<OAuthToken>;
+    get: (accountId?: string) => Promise<Token>;
+    set: (token: Partial<Token>, accountId?: string) => Promise<void>;
+    refresh?: (refreshToken: string, accountId?: string) => Promise<OAuthToken>;
 };
 export { OAuthToken, DelayStrategy, Token, AccountData, ApiCallParams, HookSettings, StatusCode, TokenService, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rendomnet/apiservice",
-  "version": "1.0.0",
+  "version": "1.3.1",
   "description": "A robust TypeScript API service framework for making authenticated API calls",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",