@rendomnet/apiservice 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rendom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# ApiService
+
+A robust TypeScript API service framework for making authenticated API calls with advanced features:
+
+- ✅ Authentication handling with token management
+- ✅ Request caching with configurable time periods
+- ✅ Advanced retry mechanisms with exponential backoff
+- ✅ Status code-specific hooks for handling errors
+- ✅ Account state tracking
+- ✅ File upload support
+
+## Usage
+
+```typescript
+import ApiService from 'apiservice';
+
+// Create and setup the API service
+const api = new ApiService();
+api.setup({
+  provider: 'my-service',
+  tokenService: myTokenService,
+  hooks: {
+    401: {
+      retryCall: true,
+      retryDelay: true,
+      callback: async (accountId, response) => {
+        // Handle token refresh logic
+        return { /* updated parameters */ };
+      }
+    }
+  },
+  cacheTime: 30000 // 30 seconds
+});
+
+// Make API calls
+const result = await api.makeApiCall({
+  accountId: 'user123',
+  method: 'GET',
+  base: 'https://api.example.com',
+  route: '/users',
+  requireAuth: true
+});
+```
+
+## Architecture
+
+The codebase is built around a main `ApiService` class that coordinates several component managers:
+
+- `HttpClient`: Handles the actual HTTP request creation and execution
+- `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 

package/dist/AccountManager.d.ts

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

package/dist/AccountManager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountManager = void 0;
+/**
+ * Manages account data and state
+ */
+class AccountManager {
+    constructor() {
+        this.accounts = {};
+    }
+    /**
+     * Update account data for a specific account
+     */
+    updateAccountData(accountId, data) {
+        this.accounts[accountId] = {
+            ...this.accounts[accountId],
+            ...data
+        };
+    }
+    /**
+     * Get account data for a specific account
+     */
+    getAccountData(accountId) {
+        return this.accounts[accountId] || {};
+    }
+    /**
+     * Check if an account's last request failed
+     */
+    didLastRequestFail(accountId) {
+        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) {
+        this.updateAccountData(accountId, { lastFailed: failed });
+    }
+    /**
+     * Update the last request time for an account
+     */
+    updateLastRequestTime(accountId) {
+        this.updateAccountData(accountId, { lastRequestTime: Date.now() });
+    }
+}
+exports.AccountManager = AccountManager;

package/dist/CacheManager.d.ts

@@ -0,0 +1,28 @@
+import { ApiCallParams } from './types';
+/**
+ * Handles caching of API responses
+ */
+export declare class CacheManager {
+    private cache;
+    private cacheTime;
+    /**
+     * Get data from cache if available and not expired
+     */
+    getFromCache(apiCallParams: ApiCallParams): any;
+    /**
+     * Save data to cache
+     */
+    saveToCache(apiCallParams: ApiCallParams, data: any): void;
+    /**
+     * Generate a unique key for caching based on request parameters
+     */
+    private getRequestKey;
+    /**
+     * Set the default cache time in milliseconds
+     */
+    setCacheTime(milliseconds: number): void;
+    /**
+     * Clear the entire cache
+     */
+    clearCache(): void;
+}

package/dist/CacheManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = void 0;
+/**
+ * Handles caching of API responses
+ */
+class CacheManager {
+    constructor() {
+        this.cache = new Map();
+        this.cacheTime = 20000; // Default cache time of 20 seconds
+    }
+    /**
+     * Get data from cache if available and not expired
+     */
+    getFromCache(apiCallParams) {
+        var _a;
+        const requestKey = this.getRequestKey(apiCallParams);
+        const currentCacheTime = (_a = apiCallParams.cacheTime) !== null && _a !== void 0 ? _a : this.cacheTime;
+        const cached = this.cache.get(requestKey);
+        if (cached && (Date.now() - cached.timestamp < currentCacheTime)) {
+            return cached.data;
+        }
+        return null;
+    }
+    /**
+     * Save data to cache
+     */
+    saveToCache(apiCallParams, data) {
+        const requestKey = this.getRequestKey(apiCallParams);
+        this.cache.set(requestKey, {
+            data,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Generate a unique key for caching based on request parameters
+     */
+    getRequestKey(apiCallParams) {
+        const { accountId, method, route, base, queryParams, body, data } = apiCallParams;
+        return JSON.stringify({
+            accountId,
+            method,
+            route,
+            base,
+            queryParams,
+            body: body || data,
+        });
+    }
+    /**
+     * Set the default cache time in milliseconds
+     */
+    setCacheTime(milliseconds) {
+        this.cacheTime = milliseconds;
+    }
+    /**
+     * Clear the entire cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+}
+exports.CacheManager = CacheManager;

package/dist/FetchError.d.ts

@@ -0,0 +1,8 @@
+export declare class FetchError extends Error {
+    name: string;
+    status: number;
+    code: string;
+    message: string;
+    data: any;
+    constructor(response: Response, data?: any, code?: string);
+}

package/dist/FetchError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchError = void 0;
+class FetchError extends Error {
+    constructor(response, data = {}, code = 'FETCH_ERROR') {
+        super();
+        this.name = 'FetchError';
+        const defaultMessage = 'An unspecified error occurred';
+        const getMessage = (data, locations) => locations
+            .map((item) => {
+            const parts = item.split('.');
+            let value = data;
+            for (const part of parts) {
+                value = value === null || value === void 0 ? void 0 : value[part];
+            }
+            return value;
+        })
+            .find((message) => typeof message === 'string') || null;
+        const messageFromData = getMessage(data, [
+            'error.errors.0.message',
+            'error.message',
+            'message',
+        ]);
+        this.message = messageFromData || response.statusText || defaultMessage;
+        this.status = response.status;
+        this.code = code;
+        this.data = data;
+        this.message = this.message || defaultMessage;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.FetchError = FetchError;

package/dist/HookManager.d.ts

@@ -0,0 +1,28 @@
+import { HookSettings, StatusCode } from './types';
+/**
+ * Manages hooks for different status codes and their processing
+ */
+export declare class HookManager {
+    private hooks;
+    private hookPromises;
+    /**
+     * Set hooks for different status codes
+     */
+    setHooks(hooks: Record<StatusCode, HookSettings>): void;
+    /**
+     * Get a hook for a specific status code
+     */
+    getHook(status: StatusCode): HookSettings | undefined;
+    /**
+     * Process a hook for a specific status code
+     */
+    processHook(accountId: string, status: StatusCode, error: any): Promise<Record<string, any> | null>;
+    /**
+     * Handle a retry failure with the appropriate hook
+     */
+    handleRetryFailure(accountId: string, status: StatusCode, error: any): Promise<void>;
+    /**
+     * Check if a hook exists and should retry for a given status
+     */
+    shouldRetry(status: StatusCode): boolean;
+}

package/dist/HookManager.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookManager = void 0;
+/**
+ * Manages hooks for different status codes and their processing
+ */
+class HookManager {
+    constructor() {
+        this.hooks = {};
+        this.hookPromises = {};
+    }
+    /**
+     * Set hooks for different status codes
+     */
+    setHooks(hooks) {
+        this.hooks = { ...this.hooks, ...hooks };
+    }
+    /**
+     * Get a hook for a specific status code
+     */
+    getHook(status) {
+        return this.hooks[status];
+    }
+    /**
+     * Process a hook for a specific status code
+     */
+    async processHook(accountId, status, error) {
+        const hook = this.hooks[status];
+        if (!hook || !hook.callback)
+            return null;
+        const hookKey = `${accountId}-${status}`;
+        try {
+            // Handle waiting for existing hook call if needed
+            if (hook.waitUntilFinished) {
+                if (!this.hookPromises[hookKey]) {
+                    this.hookPromises[hookKey] = Promise.resolve(hook.callback(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) || {};
+        }
+        catch (hookError) {
+            console.error(`Hook callback failed for status ${status}:`, hookError);
+            if (hook.errorCallback) {
+                await hook.errorCallback(accountId, hookError);
+            }
+            throw hookError;
+        }
+    }
+    /**
+     * Handle a retry failure with the appropriate hook
+     */
+    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);
+        }
+    }
+    /**
+     * Check if a hook exists and should retry for a given status
+     */
+    shouldRetry(status) {
+        const hook = this.hooks[status];
+        return !!hook && !!hook.retryCall;
+    }
+}
+exports.HookManager = HookManager;

package/dist/HttpClient.d.ts

@@ -0,0 +1,26 @@
+import { ApiCallParams, Token } from './types';
+/**
+ * Handles HTTP requests to external APIs
+ */
+export declare class HttpClient {
+    /**
+     * Make an HTTP request
+     */
+    makeRequest(apiParams: ApiCallParams, authToken: Token | Record<string, any>): Promise<any>;
+    /**
+     * Build URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Prepare form data for file uploads
+     */
+    private prepareFormData;
+    /**
+     * Build fetch options for request
+     */
+    private buildFetchOptions;
+    /**
+     * Handle API response
+     */
+    private handleResponse;
+}

package/dist/HttpClient.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const qs_1 = __importDefault(require("qs"));
+const FetchError_1 = require("./FetchError");
+const form_1 = require("./form");
+/**
+ * Handles HTTP requests to external APIs
+ */
+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;
+        // Build URL and request body
+        const url = this.buildUrl(base, route, queryParams);
+        const requestBody = body || data;
+        const normalizedMethod = method === null || method === void 0 ? void 0 : method.toUpperCase();
+        // Handle file uploads
+        const formData = this.prepareFormData(files);
+        // Create fetch options
+        const fetchOptions = this.buildFetchOptions({
+            method: normalizedMethod,
+            body: requestBody,
+            formData,
+            contentType,
+            authToken,
+            forcedAccessToken,
+            requireAuth,
+            headers,
+        });
+        // Make the request
+        try {
+            console.log(`🔄 Making API call to ${url}`);
+            const response = await fetch(url, fetchOptions);
+            return await this.handleResponse(response);
+        }
+        catch (error) {
+            console.error('🔄 Error making API call:', error);
+            throw error;
+        }
+    }
+    /**
+     * Build URL with query parameters
+     */
+    buildUrl(base, route, queryParams) {
+        let url = `${base}${route || ''}`;
+        if (queryParams)
+            url += `?${qs_1.default.stringify(queryParams)}`;
+        return url;
+    }
+    /**
+     * Prepare form data for file uploads
+     */
+    prepareFormData(files) {
+        if (!files)
+            return null;
+        const formData = (0, form_1.deserializeForm)(files);
+        // Use a workaround for TypeScript FormData entries() issue
+        const entries = formData;
+        for (let [key, value] of entries.entries()) {
+            console.log(`formdata ${key}:`, value);
+        }
+        return formData;
+    }
+    /**
+     * Build fetch options for request
+     */
+    buildFetchOptions({ method, body, formData, contentType, authToken, forcedAccessToken, requireAuth, headers, }) {
+        const allowedMethods = ['POST', 'PUT', 'PATCH'];
+        return {
+            method,
+            headers: {
+                ...(requireAuth && {
+                    Authorization: `Bearer ${forcedAccessToken || authToken.access_token}`
+                }),
+                ...(!formData && { 'content-type': contentType }),
+                ...(headers || {}),
+            },
+            body: body && allowedMethods.includes(method)
+                ? JSON.stringify(body)
+                : (formData || null),
+        };
+    }
+    /**
+     * Handle API response
+     */
+    async handleResponse(response) {
+        let data = null;
+        try {
+            data = await response.json();
+            console.log('🔄 Response data:', data);
+        }
+        catch (error) {
+            // Response wasn't JSON, continue with null data
+        }
+        if (!response.ok) {
+            throw new FetchError_1.FetchError(response, data);
+        }
+        return data;
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/RetryManager.d.ts

@@ -0,0 +1,36 @@
+import { HookSettings } from './types';
+/**
+ * Handles retry logic and delay strategies for failed API calls
+ */
+export declare class RetryManager {
+    private defaultMaxDelay;
+    private defaultMaxRetries;
+    /**
+     * Default exponential backoff strategy with full jitter
+     */
+    private defaultDelayStrategy;
+    /**
+     * Calculate and wait for appropriate delay time before retry
+     */
+    calculateAndDelay(params: {
+        attempt: number;
+        response?: any;
+        hook: HookSettings;
+    }): Promise<void>;
+    /**
+     * Extract retry-after value from response
+     */
+    private getRetryAfterValue;
+    /**
+     * Get the default maximum number of retries
+     */
+    getDefaultMaxRetries(): number;
+    /**
+     * Set the default maximum number of retries
+     */
+    setDefaultMaxRetries(maxRetries: number): void;
+    /**
+     * Set the default maximum delay between retries
+     */
+    setDefaultMaxDelay(maxDelay: number): void;
+}

package/dist/RetryManager.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryManager = void 0;
+/**
+ * Handles retry logic and delay strategies for failed API calls
+ */
+class RetryManager {
+    constructor() {
+        this.defaultMaxDelay = 60000; // Default max delay of 1 minute
+        this.defaultMaxRetries = 4;
+        /**
+         * Default exponential backoff strategy with full jitter
+         */
+        this.defaultDelayStrategy = {
+            calculate: (attempt, response) => {
+                // Check for Retry-After header
+                const retryAfter = this.getRetryAfterValue(response);
+                if (retryAfter)
+                    return retryAfter;
+                // Exponential backoff with full jitter
+                const baseDelay = 1000; // 1 second
+                const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+                return Math.floor(Math.random() * exponentialDelay);
+            },
+        };
+    }
+    /**
+     * Calculate and wait for appropriate delay time before retry
+     */
+    async calculateAndDelay(params) {
+        const { attempt, response, hook } = params;
+        const delayStrategy = hook.delayStrategy || this.defaultDelayStrategy;
+        const maxDelay = hook.maxDelay || this.defaultMaxDelay;
+        const calculatedDelay = delayStrategy.calculate(attempt, response);
+        const finalDelay = Math.min(calculatedDelay, maxDelay);
+        console.log(`🔄 Waiting for ${finalDelay / 1000} seconds before retrying.`);
+        await new Promise(resolve => setTimeout(resolve, finalDelay));
+    }
+    /**
+     * Extract retry-after value from response
+     */
+    getRetryAfterValue(response) {
+        var _a;
+        if (!((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a.get))
+            return null;
+        const retryAfter = response.headers.get('Retry-After');
+        if (!retryAfter)
+            return null;
+        // Handle numeric retry-after
+        const parsedDelay = parseInt(retryAfter, 10);
+        if (!isNaN(parsedDelay)) {
+            return parsedDelay * 1000;
+        }
+        // Handle date retry-after
+        const date = new Date(retryAfter).getTime();
+        const now = Date.now();
+        if (date > now) {
+            return date - now;
+        }
+        return null;
+    }
+    /**
+     * Get the default maximum number of retries
+     */
+    getDefaultMaxRetries() {
+        return this.defaultMaxRetries;
+    }
+    /**
+     * Set the default maximum number of retries
+     */
+    setDefaultMaxRetries(maxRetries) {
+        this.defaultMaxRetries = maxRetries;
+    }
+    /**
+     * Set the default maximum delay between retries
+     */
+    setDefaultMaxDelay(maxDelay) {
+        this.defaultMaxDelay = maxDelay;
+    }
+}
+exports.RetryManager = RetryManager;

package/dist/components.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel file exporting all ApiService components
+ */
+export { CacheManager } from './CacheManager';
+export { RetryManager } from './RetryManager';
+export { HookManager } from './HookManager';
+export { HttpClient } from './HttpClient';
+export { AccountManager } from './AccountManager';

package/dist/components.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Barrel file exporting all ApiService components
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountManager = exports.HttpClient = exports.HookManager = exports.RetryManager = exports.CacheManager = void 0;
+var CacheManager_1 = require("./CacheManager");
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return CacheManager_1.CacheManager; } });
+var RetryManager_1 = require("./RetryManager");
+Object.defineProperty(exports, "RetryManager", { enumerable: true, get: function () { return RetryManager_1.RetryManager; } });
+var HookManager_1 = require("./HookManager");
+Object.defineProperty(exports, "HookManager", { enumerable: true, get: function () { return HookManager_1.HookManager; } });
+var HttpClient_1 = require("./HttpClient");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return HttpClient_1.HttpClient; } });
+var AccountManager_1 = require("./AccountManager");
+Object.defineProperty(exports, "AccountManager", { enumerable: true, get: function () { return AccountManager_1.AccountManager; } });

package/dist/form.d.ts

@@ -0,0 +1 @@
+export declare function deserializeForm(src: any): FormData;

package/dist/form.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeForm = void 0;
+function deserializeForm(src) {
+    const fd = new FormData();
+    switch (src.cls) {
+        case 'FormData': {
+            for (const [key, items] of src.value) {
+                for (const item of items) {
+                    let deserializedItem = deserializeForm(item);
+                    if (deserializedItem instanceof FormData) {
+                        // Use a workaround for TypeScript FormData entries() issue
+                        const entries = deserializedItem;
+                        for (const [subKey, subValue] of entries.entries()) {
+                            fd.append(`${key}[${subKey}]`, subValue);
+                        }
+                    }
+                    else {
+                        fd.append(key, deserializedItem);
+                    }
+                }
+            }
+            break;
+        }
+        case 'Blob':
+        case 'File': {
+            const { type, name, lastModified } = src;
+            const binStr = atob(src.value);
+            const arr = new Uint8Array(binStr.length);
+            for (let i = 0; i < binStr.length; i++)
+                arr[i] = binStr.charCodeAt(i);
+            const data = [arr.buffer];
+            const fileOrBlob = src.cls === 'File'
+                ? new File(data, name, { type, lastModified })
+                : new Blob(data, { type });
+            fd.append('file', fileOrBlob);
+            break;
+        }
+        case 'json': {
+            fd.append('json', JSON.stringify(JSON.parse(src.value)));
+            break;
+        }
+        default:
+            throw new Error('Unsupported type for deserialization');
+    }
+    return fd;
+}
+exports.deserializeForm = deserializeForm;

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import { TokenService, ApiCallParams, HookSettings, StatusCode } from './types';
+/**
+ * ApiService - Core API service for making authenticated API calls
+ * with caching, retry, and hook support.
+ */
+declare class ApiService {
+    provider: string;
+    private tokenService;
+    private cacheManager;
+    private retryManager;
+    private hookManager;
+    private httpClient;
+    private accountManager;
+    private maxAttempts;
+    constructor();
+    /**
+     * Setup the API service
+     */
+    setup({ provider, tokenService, hooks, cacheTime, }: {
+        provider: string;
+        tokenService: TokenService;
+        hooks?: Record<StatusCode, HookSettings>;
+        cacheTime: number;
+    }): void;
+    /**
+     * Set the maximum number of retry attempts
+     */
+    setMaxAttempts(attempts: number): void;
+    /**
+     * Update account data
+     */
+    updateAccountData(accountId: string, data: Partial<Record<string, any>>): void;
+    /**
+     * Main API call method
+     */
+    makeApiCall(apiCallParams: ApiCallParams): Promise<any>;
+    /**
+     * Make a request with retry capability
+     */
+    private makeRequestWithRetry;
+    /**
+     * Set the cache time in milliseconds
+     */
+    setCacheTime(milliseconds: number): void;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+}
+export default ApiService;

package/dist/index.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const components_1 = require("./components");
+/**
+ * ApiService - Core API service for making authenticated API calls
+ * with caching, retry, and hook support.
+ */
+class ApiService {
+    constructor() {
+        // Default max attempts for API calls
+        this.maxAttempts = 10;
+        this.provider = '';
+        this.tokenService = {};
+        // Initialize component managers
+        this.cacheManager = new components_1.CacheManager();
+        this.retryManager = new components_1.RetryManager();
+        this.hookManager = new components_1.HookManager();
+        this.httpClient = new components_1.HttpClient();
+        this.accountManager = new components_1.AccountManager();
+    }
+    /**
+     * Setup the API service
+     */
+    setup({ provider, tokenService, hooks, cacheTime, }) {
+        this.provider = provider;
+        this.tokenService = tokenService;
+        if (hooks) {
+            this.hookManager.setHooks(hooks);
+        }
+        if (typeof cacheTime !== 'undefined') {
+            this.cacheManager.setCacheTime(cacheTime);
+        }
+    }
+    /**
+     * Set the maximum number of retry attempts
+     */
+    setMaxAttempts(attempts) {
+        this.maxAttempts = attempts;
+    }
+    /**
+     * Update account data
+     */
+    updateAccountData(accountId, data) {
+        this.accountManager.updateAccountData(accountId, data);
+    }
+    /**
+     * Main API call method
+     */
+    async makeApiCall(apiCallParams) {
+        console.log('🔄 makeApiCall', this.provider, apiCallParams.accountId);
+        // Check cache first
+        const cachedData = this.cacheManager.getFromCache(apiCallParams);
+        if (cachedData)
+            return cachedData;
+        // Make the API call with retry capability
+        const result = await this.makeRequestWithRetry(apiCallParams);
+        // Cache the result
+        this.cacheManager.saveToCache(apiCallParams, result);
+        return result;
+    }
+    /**
+     * Make a request with retry capability
+     */
+    async makeRequestWithRetry(apiCallParams) {
+        var _a;
+        const { accountId } = apiCallParams;
+        let attempts = 0;
+        const statusRetries = {};
+        // Copy the params to avoid mutation issues
+        let currentParams = { ...apiCallParams };
+        // Main retry loop
+        while (attempts < this.maxAttempts) {
+            attempts++;
+            try {
+                // Get authentication token if needed
+                const authToken = apiCallParams.requireAuth !== false
+                    ? await this.tokenService.get(accountId)
+                    : {};
+                // Verify we have authentication if required
+                if (apiCallParams.requireAuth !== false && !apiCallParams.accessToken && !authToken.access_token) {
+                    throw new Error(`${this.provider} credentials not found for account ID ${accountId}`);
+                }
+                // Make the actual API call
+                const response = await this.httpClient.makeRequest(currentParams, authToken);
+                // Success - update account status and return result
+                this.accountManager.setLastRequestFailed(accountId, false);
+                return response;
+            }
+            catch (error) {
+                const status = error === null || error === void 0 ? void 0 : error.status;
+                // If no hook exists for this error, or we shouldn't retry, throw
+                if (!this.hookManager.shouldRetry(status)) {
+                    throw error;
+                }
+                // Track retries for this status code
+                statusRetries[status] = (statusRetries[status] || 0) + 1;
+                const activeHook = this.hookManager.getHook(status);
+                const maxRetries = (_a = activeHook === null || activeHook === void 0 ? void 0 : activeHook.maxRetries) !== null && _a !== void 0 ? _a : this.retryManager.getDefaultMaxRetries();
+                // Check if we've exceeded retries for this status
+                if (statusRetries[status] > maxRetries) {
+                    await this.hookManager.handleRetryFailure(accountId, status, error);
+                    this.accountManager.setLastRequestFailed(accountId, true);
+                    throw error;
+                }
+                // Process the hook to get updated params
+                try {
+                    const hookResult = await this.hookManager.processHook(accountId, status, error);
+                    if (hookResult) {
+                        currentParams = { ...currentParams, ...hookResult };
+                    }
+                }
+                catch (hookError) {
+                    this.accountManager.setLastRequestFailed(accountId, true);
+                    throw hookError;
+                }
+                // Wait before retrying if needed
+                if (activeHook === null || activeHook === void 0 ? void 0 : activeHook.retryDelay) {
+                    await this.retryManager.calculateAndDelay({
+                        attempt: statusRetries[status],
+                        response: error.response,
+                        hook: activeHook,
+                    });
+                }
+            }
+        }
+        // If we've reached here, we've exceeded our maximum attempts
+        this.accountManager.setLastRequestFailed(accountId, true);
+        throw new Error(`Exceeded maximum attempts (${this.maxAttempts}) for API call to ${accountId}`);
+    }
+    /**
+     * Set the cache time in milliseconds
+     */
+    setCacheTime(milliseconds) {
+        this.cacheManager.setCacheTime(milliseconds);
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cacheManager.clearCache();
+    }
+}
+exports.default = ApiService;

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+interface OAuthToken {
+    access_token: string;
+    expires_in: number;
+    id_token: string;
+    refresh_token: string;
+    scope: string;
+    token_type: string;
+}
+interface Token {
+    accountId: string;
+    access_token: string;
+    refresh_token: string;
+    provider: string;
+    enabled?: boolean;
+    updatedAt?: string;
+    primary?: boolean;
+}
+interface AccountData {
+    lastRequestTime?: number;
+    lastFailed?: boolean;
+    token?: Token;
+}
+interface DelayStrategy {
+    calculate: (attempt: number, response?: any) => number;
+}
+interface ApiCallParams {
+    accountId: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    route: string;
+    base: string;
+    body?: object;
+    data?: object;
+    headers?: Record<string, string>;
+    queryParams?: URLSearchParams;
+    accessToken?: string;
+    requireAuth?: boolean;
+    noContentType?: boolean;
+    contentType?: string;
+    cacheTime?: number;
+    files?: File[];
+}
+interface HookSettings {
+    retryCall: boolean;
+    retryDelay: boolean;
+    waitUntilFinished?: boolean;
+    maxRetries?: number;
+    callback: (accountId: string, response: any) => Promise<any>;
+    onRetryFail?: (accountId: string, error: any) => Promise<void>;
+    errorCallback?: (accountId: string, error: any) => Promise<void>;
+    delayStrategy?: DelayStrategy;
+    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>;
+};
+export { OAuthToken, DelayStrategy, Token, AccountData, ApiCallParams, HookSettings, StatusCode, TokenService, };

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@rendomnet/apiservice",
+  "version": "1.0.0",
+  "description": "A robust TypeScript API service framework for making authenticated API calls",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "api",
+    "service",
+    "typescript",
+    "fetch",
+    "retry",
+    "cache",
+    "hooks"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rendomnet/apiservice.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rendomnet/apiservice/issues"
+  },
+  "homepage": "https://github.com/rendomnet/apiservice#readme",
+  "dependencies": {
+    "qs": "^6.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "@types/qs": "^6.9.7",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.7.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}