@rendomnet/apiservice 1.3.8 → 1.4.0

package/dist/index.mjs

@@ -0,0 +1,651 @@
+// src/ApiKeyAuthProvider.ts
+var ApiKeyAuthProvider = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.headerName = options.headerName;
+    this.queryParamName = options.queryParamName;
+  }
+  async getAuthHeaders() {
+    if (this.headerName) {
+      return { [this.headerName]: this.apiKey };
+    }
+    return {};
+  }
+  // For API key, refresh is not supported
+};
+
+// src/CacheManager.ts
+var CacheManager = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cacheTime = 2e4;
+  }
+  // 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 : 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();
+  }
+};
+
+// src/RetryManager.ts
+var RetryManager = class {
+  constructor() {
+    this.defaultMaxDelay = 6e4;
+    // Default max delay of 1 minute
+    this.defaultMaxRetries = 4;
+    /**
+     * Default exponential backoff strategy with full jitter
+     */
+    this.defaultDelayStrategy = {
+      calculate: (attempt, response) => {
+        const retryAfter = this.getRetryAfterValue(response);
+        if (retryAfter) return retryAfter;
+        const baseDelay = 1e3;
+        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(`\u{1F504} Waiting for ${finalDelay / 1e3} seconds before retrying.`);
+    await new Promise((resolve) => setTimeout(resolve, finalDelay));
+  }
+  /**
+   * Extract retry-after value from response
+   */
+  getRetryAfterValue(response) {
+    var _a;
+    if (!((_a = response == null ? void 0 : response.headers) == null ? void 0 : _a.get)) return null;
+    const retryAfter = response.headers.get("Retry-After");
+    if (!retryAfter) return null;
+    const parsedDelay = parseInt(retryAfter, 10);
+    if (!isNaN(parsedDelay)) {
+      return parsedDelay * 1e3;
+    }
+    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;
+  }
+};
+
+// src/HookManager.ts
+var HookManager = class {
+  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.handler) return null;
+    const hookKey = `${accountId || "default"}-${status}`;
+    try {
+      if (hook.preventConcurrentCalls) {
+        if (!this.hookPromises[hookKey]) {
+          this.hookPromises[hookKey] = Promise.resolve(
+            hook.handler(accountId, error.response) || {}
+          );
+        }
+        const result = await this.hookPromises[hookKey];
+        delete this.hookPromises[hookKey];
+        return result;
+      }
+      return await hook.handler(accountId, error.response) || {};
+    } catch (hookError) {
+      console.error(`Hook handler failed for status ${status}:`, hookError);
+      if (hook.onHandlerError) {
+        await hook.onHandlerError(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 ? void 0 : hook.onMaxRetriesExceeded) {
+      await hook.onMaxRetriesExceeded(accountId, error);
+    }
+  }
+  /**
+   * Check if a hook exists and should retry for a given status
+   */
+  shouldRetry(status) {
+    const hook = this.hooks[status];
+    return !!hook && !!hook.shouldRetry;
+  }
+};
+
+// src/HttpClient.ts
+import qs from "qs";
+
+// src/FetchError.ts
+var FetchError = class extends Error {
+  constructor(response, data = {}, code = "FETCH_ERROR") {
+    super();
+    this.name = "FetchError";
+    const defaultMessage = "An unspecified error occurred";
+    const getMessage = (data2, locations) => locations.map((item) => {
+      const parts = item.split(".");
+      let value = data2;
+      for (const part of parts) {
+        value = value == null ? void 0 : value[part];
+      }
+      return value;
+    }).find((message) => typeof message === "string") || null;
+    const messageFromData = getMessage(data, [
+      "error.errors.0.message",
+      "error.message",
+      "error",
+      "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);
+  }
+};
+
+// src/form.ts
+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) {
+            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;
+}
+
+// src/HttpClient.ts
+var HttpClient = class {
+  /**
+   * Make an HTTP request
+   */
+  async makeRequest(apiParams, authToken) {
+    const {
+      accountId,
+      method,
+      route,
+      base,
+      body,
+      data,
+      headers,
+      queryParams,
+      contentType = "application/json",
+      accessToken: forcedAccessToken,
+      useAuth = true,
+      files,
+      abortSignal
+    } = apiParams;
+    const normalizedMethod = method == null ? void 0 : method.toUpperCase();
+    let finalQueryParams = {};
+    if (queryParams) {
+      if (queryParams instanceof URLSearchParams) {
+        queryParams.forEach((val, key) => {
+          finalQueryParams[key] = val;
+        });
+      } else {
+        finalQueryParams = { ...queryParams };
+      }
+    }
+    if (normalizedMethod === "GET") {
+      if (body) {
+        finalQueryParams = { ...finalQueryParams, ...body };
+      }
+      if (data) {
+        finalQueryParams = { ...finalQueryParams, ...data };
+      }
+    }
+    const url = this.buildUrl(base, route, finalQueryParams);
+    const requestBody = body || data;
+    const formData = this.prepareFormData(files);
+    const fetchOptions = this.buildFetchOptions({
+      method: normalizedMethod,
+      body: requestBody,
+      formData,
+      contentType,
+      authToken,
+      forcedAccessToken,
+      useAuth,
+      headers,
+      abortSignal
+    });
+    try {
+      console.log(`\u{1F504} Making API call to ${url}`);
+      const response = await fetch(url, fetchOptions);
+      return await this.handleResponse(response);
+    } catch (error) {
+      console.error("\u{1F504} Error making API call:", error, "status:", error == null ? void 0 : error.status);
+      throw error;
+    }
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(base, route, queryParams) {
+    const baseUrl = base || "";
+    let url = `${baseUrl}${route || ""}`;
+    if (queryParams && Object.keys(queryParams).length > 0) {
+      url += `?${qs.stringify(queryParams)}`;
+    }
+    return url;
+  }
+  /**
+   * Prepare form data for file uploads
+   */
+  prepareFormData(files) {
+    if (!files) return null;
+    const formData = deserializeForm(files);
+    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,
+    useAuth,
+    headers,
+    abortSignal
+  }) {
+    const allowedMethods = ["POST", "PUT", "PATCH"];
+    return {
+      method,
+      signal: abortSignal,
+      headers: {
+        ...useAuth && {
+          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("\u{1F504} Response data:", data);
+    } catch (error) {
+    }
+    if (!response.ok) {
+      throw new FetchError(response, data);
+    }
+    return data;
+  }
+};
+
+// src/AccountManager.ts
+var AccountManager = class {
+  constructor() {
+    this.accounts = {};
+    this.DEFAULT_ACCOUNT = "default";
+  }
+  /**
+   * Update account data for a specific account
+   */
+  updateAccountData(accountId = this.DEFAULT_ACCOUNT, data) {
+    this.accounts[accountId] = {
+      ...this.accounts[accountId],
+      ...data
+    };
+  }
+  /**
+   * Get account data for a specific account
+   */
+  getAccountData(accountId = this.DEFAULT_ACCOUNT) {
+    return this.accounts[accountId] || {};
+  }
+  /**
+   * Check if an account's last request failed
+   */
+  didLastRequestFail(accountId = this.DEFAULT_ACCOUNT) {
+    var _a;
+    return !!((_a = this.accounts[accountId]) == null ? void 0 : _a.lastFailed);
+  }
+  /**
+   * Set account's last request as failed
+   */
+  setLastRequestFailed(accountId = this.DEFAULT_ACCOUNT, failed = true) {
+    this.updateAccountData(accountId, { lastFailed: failed });
+  }
+  /**
+   * Update the last request time for an account
+   */
+  updateLastRequestTime(accountId = this.DEFAULT_ACCOUNT) {
+    this.updateAccountData(accountId, { lastRequestTime: Date.now() });
+  }
+};
+
+// src/index.ts
+var ApiService = class {
+  constructor() {
+    this.baseUrl = "";
+    // Default max attempts for API calls
+    this.maxAttempts = 10;
+    this.provider = "";
+    this.authProvider = {};
+    this.cacheManager = new CacheManager();
+    this.retryManager = new RetryManager();
+    this.hookManager = new HookManager();
+    this.httpClient = new HttpClient();
+    this.accountManager = new AccountManager();
+  }
+  /**
+   * Setup the API service
+   */
+  setup({
+    provider,
+    authProvider,
+    hooks = {},
+    cacheTime,
+    baseUrl = ""
+  }) {
+    this.provider = provider;
+    this.authProvider = authProvider;
+    this.baseUrl = baseUrl;
+    const finalHooks = {};
+    if (hooks[401] === void 0 && typeof this.authProvider.refresh === "function") {
+      finalHooks[401] = this.createDefaultAuthRefreshHandler();
+    }
+    for (const [statusCode, hook] of Object.entries(hooks)) {
+      if (hook) {
+        finalHooks[statusCode] = hook;
+      }
+    }
+    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 credential refresh behavior
+   */
+  createDefaultAuthRefreshHandler() {
+    return {
+      shouldRetry: true,
+      useRetryDelay: true,
+      preventConcurrentCalls: true,
+      maxRetries: 1,
+      handler: async (accountId) => {
+        try {
+          console.log(`\u{1F504} Using default auth refresh handler for ${accountId}`);
+          if (!this.authProvider.refresh) {
+            throw new Error("No refresh method available on auth provider");
+          }
+          await this.authProvider.refresh(accountId);
+          return {};
+        } catch (error) {
+          console.error(`Auth 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
+   */
+  setMaxAttempts(attempts) {
+    this.maxAttempts = attempts;
+  }
+  /**
+   * Update account data
+   */
+  updateAccountData(accountId, data) {
+    this.accountManager.updateAccountData(accountId, data);
+  }
+  /**
+   * Make an API call with all features (caching, retry, hooks)
+   */
+  async call(apiCallParams) {
+    const params = {
+      ...apiCallParams,
+      accountId: apiCallParams.accountId || "default",
+      base: apiCallParams.base || this.baseUrl
+    };
+    if (this.authProvider instanceof ApiKeyAuthProvider && this.authProvider.queryParamName) {
+      const queryParamName = this.authProvider.queryParamName;
+      const apiKey = this.authProvider.apiKey;
+      const urlParams = params.queryParams ? new URLSearchParams(params.queryParams) : new URLSearchParams();
+      urlParams.set(queryParamName, apiKey);
+      params.queryParams = urlParams;
+    }
+    console.log("\u{1F504} API call", this.provider, params.accountId, params.method, params.route);
+    const cachedData = this.cacheManager.getFromCache(params);
+    if (cachedData) return cachedData;
+    const result = await this.makeRequestWithRetry(params);
+    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
+   */
+  async makeRequestWithRetry(apiCallParams) {
+    var _a;
+    const { accountId, abortSignal } = apiCallParams;
+    let attempts = 0;
+    const statusRetries = {};
+    let currentParams = { ...apiCallParams };
+    if (this.authProvider instanceof ApiKeyAuthProvider && this.authProvider.queryParamName) {
+      const queryParamName = this.authProvider.queryParamName;
+      const apiKey = this.authProvider.apiKey;
+      const urlParams = currentParams.queryParams ? new URLSearchParams(currentParams.queryParams) : new URLSearchParams();
+      urlParams.set(queryParamName, apiKey);
+      currentParams.queryParams = urlParams;
+    }
+    while (attempts < this.maxAttempts) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        throw new Error("Request aborted");
+      }
+      attempts++;
+      try {
+        const authHeaders = apiCallParams.useAuth !== false ? await this.authProvider.getAuthHeaders(accountId) : {};
+        currentParams.headers = {
+          ...currentParams.headers || {},
+          ...authHeaders
+        };
+        if (apiCallParams.useAuth !== false && Object.keys(authHeaders).length === 0 && !(this.authProvider instanceof ApiKeyAuthProvider && this.authProvider.queryParamName)) {
+          throw new Error(`${this.provider} credentials not found for account ID ${accountId}`);
+        }
+        const response = await this.httpClient.makeRequest(currentParams, {});
+        this.accountManager.setLastRequestFailed(accountId, false);
+        return response;
+      } catch (error) {
+        const status = error == null ? void 0 : error.status;
+        if (!this.hookManager.shouldRetry(status)) {
+          throw error;
+        }
+        statusRetries[status] = (statusRetries[status] || 0) + 1;
+        const activeHook = this.hookManager.getHook(status);
+        const maxRetries = (_a = activeHook == null ? void 0 : activeHook.maxRetries) != null ? _a : this.retryManager.getDefaultMaxRetries();
+        if (statusRetries[status] > maxRetries) {
+          await this.hookManager.handleRetryFailure(accountId, status, error);
+          this.accountManager.setLastRequestFailed(accountId, true);
+          throw error;
+        }
+        try {
+          const hookResult = await this.hookManager.processHook(accountId, status, error);
+          if (hookResult) {
+            currentParams = { ...currentParams, ...hookResult };
+          }
+        } catch (hookError) {
+          this.accountManager.setLastRequestFailed(accountId, true);
+          throw hookError;
+        }
+        if (activeHook == null ? void 0 : activeHook.useRetryDelay) {
+          await this.retryManager.calculateAndDelay({
+            attempt: statusRetries[status],
+            response: error.response,
+            hook: activeHook
+          });
+        }
+      }
+    }
+    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();
+  }
+};
+var index_default = ApiService;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map