@thorprovider/adapters 3.0.2

package/src/core/errors.ts

@@ -0,0 +1,132 @@
+/**
+ * @thorprovider/adapters v2.0
+ * Core errors
+ */
+
+/**
+ * Base error class for commerce providers
+ */
+export class CommerceError extends Error {
+  constructor(
+    message: string,
+    public readonly code?: string,
+    public readonly status?: number
+  ) {
+    super(message);
+    this.name = 'CommerceError';
+  }
+}
+
+/**
+ * Provider not found error
+ */
+export class ProviderNotFoundError extends CommerceError {
+  constructor(providerName: string) {
+    super(`Provider not found: ${providerName}`, 'PROVIDER_NOT_FOUND');
+    this.name = 'ProviderNotFoundError';
+  }
+}
+
+/**
+ * Configuration error
+ */
+export class ConfigurationError extends CommerceError {
+  constructor(message: string) {
+    super(message, 'CONFIGURATION_ERROR');
+    this.name = 'ConfigurationError';
+  }
+}
+
+/**
+ * Resource not found error
+ */
+export class ResourceNotFoundError extends CommerceError {
+  constructor(resource: string, identifier: string) {
+    super(`${resource} not found: ${identifier}`, 'RESOURCE_NOT_FOUND', 404);
+    this.name = 'ResourceNotFoundError';
+  }
+}
+
+/**
+ * API error from provider
+ */
+export class ProviderAPIError extends CommerceError {
+  constructor(
+    message: string,
+    public readonly provider: string,
+    status?: number
+  ) {
+    super(message, 'PROVIDER_API_ERROR', status);
+    this.name = 'ProviderAPIError';
+  }
+}
+
+/**
+ * Extract error message from various error types
+ * Handles standard Error objects, API responses, and unknown error types
+ */
+export function extractErrorMessage(error: unknown): string {
+  // Standard Error object
+  if (error instanceof Error && error.message) {
+    // Don't return generic messages if there's more data
+    if (error.message !== 'An unknown error occurred.') {
+      return error.message;
+    }
+  }
+  
+  // Object with message property
+  if (typeof error === 'object' && error !== null) {
+    const err = error as any;
+    
+    // Check for response body (common in fetch errors)
+    if (err.body) {
+      if (typeof err.body === 'string') return err.body;
+      if (err.body.message) return String(err.body.message);
+      if (err.body.error?.message) return String(err.body.error.message);
+    }
+    
+    // Check for response object
+    if (err.response) {
+      if (err.response.data?.message) return String(err.response.data.message);
+      if (err.response.data?.error) return String(err.response.data.error);
+      if (err.response.statusText) return `${err.response.status || ''} ${err.response.statusText}`.trim();
+    }
+    
+    // Check for data property
+    if (err.data?.message) return String(err.data.message);
+    if (err.data?.error) return String(err.data.error);
+    
+    // Check for error property
+    if (err.error?.message) return String(err.error.message);
+    
+    // Check for statusText with status code
+    if (err.status && err.statusText) {
+      return `HTTP ${err.status}: ${err.statusText}`;
+    }
+    
+    if (err.status && !err.statusText) {
+      return `HTTP ${err.status} Error`;
+    }
+    
+    // Check for message property (not generic)
+    if (err.message && err.message !== 'An unknown error occurred.') {
+      return String(err.message);
+    }
+    
+    // Try to stringify the error object
+    try {
+      const stringified = JSON.stringify(error);
+      if (stringified !== '{}') return stringified;
+    } catch {
+      // Ignore JSON.stringify errors
+    }
+  }
+  
+  // String error
+  if (typeof error === 'string') {
+    return error;
+  }
+  
+  // Fallback
+  return 'An unknown error occurred';
+}

package/src/core/fetch-utils.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * @thorprovider/adapters v2.0
+ * Fetch Utilities - Retry logic, timeouts, and error handling
+ *
+ * This module provides enhanced fetch capabilities with:
+ * - Automatic retries with exponential backoff
+ * - Configurable timeouts
+ * - Better error handling for network failures
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithRetry = fetchWithRetry;
+exports.createFetchWithRetry = createFetchWithRetry;
+var logger_1 = require("./logger");
+var logger = (0, logger_1.createLogger)('FetchUtils');
+var DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    initialDelayMs: 300,
+    backoffMultiplier: 2,
+    maxDelayMs: 5000,
+    timeoutMs: 10000, // 10 seconds
+    retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+};
+/**
+ * Sleep utility for delays between retries
+ */
+function sleep(ms) {
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+}
+/**
+ * Calculate delay for exponential backoff
+ */
+function calculateDelay(attempt, config) {
+    var delay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
+    return Math.min(delay, config.maxDelayMs);
+}
+/**
+ * Check if error is retryable
+ */
+function isRetryableError(error, config) {
+    var _a, _b;
+    // Network errors (fetch failed, connection refused, etc.)
+    if (error.name === 'TypeError' || ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('fetch failed'))) {
+        return true;
+    }
+    // Timeout errors
+    if (error.name === 'AbortError' || ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('timeout'))) {
+        return true;
+    }
+    // HTTP status codes
+    if (error.status && config.retryableStatusCodes.includes(error.status)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Enhanced fetch with retry logic and timeout
+ *
+ * @example
+ * ```typescript
+ * import { fetchWithRetry } from '@thorprovider/adapters/core/fetch-utils';
+ *
+ * // Basic usage with defaults (3 retries, 10s timeout)
+ * const response = await fetchWithRetry('https://api.example.com/products');
+ *
+ * // Custom configuration
+ * const response = await fetchWithRetry(
+ *   'https://api.example.com/products',
+ *   {
+ *     method: 'POST',
+ *     body: JSON.stringify({ name: 'Product' }),
+ *   },
+ *   {
+ *     maxRetries: 5,
+ *     timeoutMs: 15000, // 15 seconds
+ *     initialDelayMs: 500,
+ *   }
+ * );
+ * ```
+ */
+function fetchWithRetry(url, init, retryConfig) {
+    return __awaiter(this, void 0, void 0, function () {
+        var config, lastError, _loop_1, attempt, state_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = __assign(__assign({}, DEFAULT_RETRY_CONFIG), retryConfig);
+                    _loop_1 = function (attempt) {
+                        var controller_1, timeoutId, fetchOptions, response, error, error_1, shouldRetry, delay;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    _b.trys.push([0, 2, , 6]);
+                                    controller_1 = new AbortController();
+                                    timeoutId = setTimeout(function () { return controller_1.abort(); }, config.timeoutMs);
+                                    fetchOptions = __assign(__assign({}, init), { signal: controller_1.signal });
+                                    logger.debug('Fetch attempt', {
+                                        url: url,
+                                        attempt: attempt + 1,
+                                        maxAttempts: config.maxRetries + 1,
+                                        timeout: config.timeoutMs,
+                                    });
+                                    return [4 /*yield*/, fetch(url, fetchOptions)];
+                                case 1:
+                                    response = _b.sent();
+                                    // Clear timeout
+                                    clearTimeout(timeoutId);
+                                    // Check if status code is retryable
+                                    if (!response.ok && config.retryableStatusCodes.includes(response.status)) {
+                                        error = new Error("HTTP ".concat(response.status, ": ").concat(response.statusText));
+                                        error.status = response.status;
+                                        throw error;
+                                    }
+                                    // Success!
+                                    logger.debug('Fetch successful', { url: url, attempt: attempt + 1 });
+                                    return [2 /*return*/, { value: response }];
+                                case 2:
+                                    error_1 = _b.sent();
+                                    lastError = error_1;
+                                    // Clear timeout if it exists
+                                    if (error_1.name === 'AbortError') {
+                                        lastError = new Error("Request timeout after ".concat(config.timeoutMs, "ms"));
+                                        lastError.name = 'TimeoutError';
+                                    }
+                                    shouldRetry = attempt < config.maxRetries && isRetryableError(error_1, config);
+                                    if (!shouldRetry) return [3 /*break*/, 4];
+                                    delay = calculateDelay(attempt, config);
+                                    logger.warn('Fetch failed, retrying...', {
+                                        url: url,
+                                        attempt: attempt + 1,
+                                        maxAttempts: config.maxRetries + 1,
+                                        nextRetryIn: "".concat(delay, "ms"),
+                                        error: error_1.message,
+                                    });
+                                    return [4 /*yield*/, sleep(delay)];
+                                case 3:
+                                    _b.sent();
+                                    return [3 /*break*/, 5];
+                                case 4:
+                                    logger.error('Fetch failed after all retries', {
+                                        url: url,
+                                        totalAttempts: attempt + 1,
+                                        error: error_1.message,
+                                    });
+                                    return [2 /*return*/, "break"];
+                                case 5: return [3 /*break*/, 6];
+                                case 6: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    attempt = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(attempt <= config.maxRetries)) return [3 /*break*/, 4];
+                    return [5 /*yield**/, _loop_1(attempt)];
+                case 2:
+                    state_1 = _a.sent();
+                    if (typeof state_1 === "object")
+                        return [2 /*return*/, state_1.value];
+                    if (state_1 === "break")
+                        return [3 /*break*/, 4];
+                    _a.label = 3;
+                case 3:
+                    attempt++;
+                    return [3 /*break*/, 1];
+                case 4: 
+                // All retries exhausted, throw the last error
+                throw lastError;
+            }
+        });
+    });
+}
+/**
+ * Create a fetch function with custom retry configuration
+ * Useful for creating a configured fetch instance
+ *
+ * @example
+ * ```typescript
+ * import { createFetchWithRetry } from '@thorprovider/adapters/core/fetch-utils';
+ *
+ * // Create configured fetch
+ * const customFetch = createFetchWithRetry({
+ *   maxRetries: 5,
+ *   timeoutMs: 15000,
+ * });
+ *
+ * // Use it like regular fetch
+ * const response = await customFetch('https://api.example.com/products');
+ * ```
+ */
+function createFetchWithRetry(retryConfig) {
+    return function (url, init) { return fetchWithRetry(url, init, retryConfig); };
+}

package/src/core/fetch-utils.ts

@@ -0,0 +1,227 @@
+/**
+ * @thorprovider/adapters v2.0
+ * Fetch Utilities - Retry logic, timeouts, and error handling
+ * 
+ * This module provides enhanced fetch capabilities with:
+ * - Automatic retries with exponential backoff
+ * - Configurable timeouts
+ * - Better error handling for network failures
+ */
+
+import { createLogger } from './logger';
+
+const logger = createLogger('FetchUtils');
+
+/**
+ * Configuration for fetch retry behavior
+ */
+export interface RetryConfig {
+  /**
+   * Maximum number of retry attempts (default: 3)
+   */
+  maxRetries?: number;
+  
+  /**
+   * Initial delay in milliseconds before first retry (default: 300ms)
+   */
+  initialDelayMs?: number;
+  
+  /**
+   * Multiplier for exponential backoff (default: 2)
+   */
+  backoffMultiplier?: number;
+  
+  /**
+   * Maximum delay between retries in milliseconds (default: 5000ms)
+   */
+  maxDelayMs?: number;
+  
+  /**
+   * Timeout for each fetch attempt in milliseconds (default: 10000ms - 10 seconds)
+   */
+  timeoutMs?: number;
+  
+  /**
+   * HTTP status codes that should trigger a retry (default: [408, 429, 500, 502, 503, 504])
+   */
+  retryableStatusCodes?: number[];
+}
+
+const DEFAULT_RETRY_CONFIG: Required<RetryConfig> = {
+  maxRetries: 3,
+  initialDelayMs: 300,
+  backoffMultiplier: 2,
+  maxDelayMs: 5000,
+  timeoutMs: 10000, // 10 seconds
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+};
+
+/**
+ * Sleep utility for delays between retries
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Calculate delay for exponential backoff
+ */
+function calculateDelay(
+  attempt: number,
+  config: Required<RetryConfig>
+): number {
+  const delay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
+  return Math.min(delay, config.maxDelayMs);
+}
+
+/**
+ * Check if error is retryable
+ */
+function isRetryableError(error: any, config: Required<RetryConfig>): boolean {
+  // Network errors (fetch failed, connection refused, etc.)
+  if (error.name === 'TypeError' || error.message?.includes('fetch failed')) {
+    return true;
+  }
+  
+  // Timeout errors
+  if (error.name === 'AbortError' || error.message?.includes('timeout')) {
+    return true;
+  }
+  
+  // HTTP status codes
+  if (error.status && config.retryableStatusCodes.includes(error.status)) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Enhanced fetch with retry logic and timeout
+ * 
+ * @example
+ * ```typescript
+ * import { fetchWithRetry } from '@thorprovider/adapters/core/fetch-utils';
+ * 
+ * // Basic usage with defaults (3 retries, 10s timeout)
+ * const response = await fetchWithRetry('https://api.example.com/products');
+ * 
+ * // Custom configuration
+ * const response = await fetchWithRetry(
+ *   'https://api.example.com/products',
+ *   {
+ *     method: 'POST',
+ *     body: JSON.stringify({ name: 'Product' }),
+ *   },
+ *   {
+ *     maxRetries: 5,
+ *     timeoutMs: 15000, // 15 seconds
+ *     initialDelayMs: 500,
+ *   }
+ * );
+ * ```
+ */
+export async function fetchWithRetry(
+  url: string,
+  init?: RequestInit,
+  retryConfig?: RetryConfig
+): Promise<Response> {
+  const config = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
+  let lastError: any;
+  
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    try {
+      // Create AbortController for timeout
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), config.timeoutMs);
+      
+      const fetchOptions: RequestInit = {
+        ...init,
+        signal: controller.signal,
+      };
+      
+      logger.debug('Fetch attempt', {
+        url,
+        attempt: attempt + 1,
+        maxAttempts: config.maxRetries + 1,
+        timeout: config.timeoutMs,
+      });
+      
+      // Execute fetch
+      const response = await fetch(url, fetchOptions);
+      
+      // Clear timeout
+      clearTimeout(timeoutId);
+      
+      // Check if status code is retryable
+      if (!response.ok && config.retryableStatusCodes.includes(response.status)) {
+        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+        (error as any).status = response.status;
+        throw error;
+      }
+      
+      // Success!
+      logger.debug('Fetch successful', { url, attempt: attempt + 1 });
+      return response;
+      
+    } catch (error: any) {
+      lastError = error;
+      
+      // Clear timeout if it exists
+      if (error.name === 'AbortError') {
+        lastError = new Error(`Request timeout after ${config.timeoutMs}ms`);
+        lastError.name = 'TimeoutError';
+      }
+      
+      // Check if we should retry
+      const shouldRetry = attempt < config.maxRetries && isRetryableError(error, config);
+      
+      if (shouldRetry) {
+        const delay = calculateDelay(attempt, config);
+        logger.warn('Fetch failed, retrying...', {
+          url,
+          attempt: attempt + 1,
+          maxAttempts: config.maxRetries + 1,
+          nextRetryIn: `${delay}ms`,
+          error: error.message,
+        });
+        
+        await sleep(delay);
+      } else {
+        logger.error('Fetch failed after all retries', {
+          url,
+          totalAttempts: attempt + 1,
+          error: error.message,
+        });
+        break;
+      }
+    }
+  }
+  
+  // All retries exhausted, throw the last error
+  throw lastError;
+}
+
+/**
+ * Create a fetch function with custom retry configuration
+ * Useful for creating a configured fetch instance
+ * 
+ * @example
+ * ```typescript
+ * import { createFetchWithRetry } from '@thorprovider/adapters/core/fetch-utils';
+ * 
+ * // Create configured fetch
+ * const customFetch = createFetchWithRetry({
+ *   maxRetries: 5,
+ *   timeoutMs: 15000,
+ * });
+ * 
+ * // Use it like regular fetch
+ * const response = await customFetch('https://api.example.com/products');
+ * ```
+ */
+export function createFetchWithRetry(
+  retryConfig?: RetryConfig
+): (url: string, init?: RequestInit) => Promise<Response> {
+  return (url: string, init?: RequestInit) => fetchWithRetry(url, init, retryConfig);
+}

package/src/core/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @thorprovider/adapters v2.0
+ * Core utilities exports
+ */
+
+export * from './errors';
+export * from './logger';
+export * from './fetch-utils';

package/src/core/logger.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * @thorprovider/adapters v2.0
+ * Core logger utility
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+/**
+ * Create a logger instance
+ */
+function createLogger(namespace, enabled) {
+    if (enabled === void 0) { enabled = false; }
+    var log = function (level, message) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        if (!enabled && level !== 'error')
+            return;
+        var timestamp = new Date().toISOString();
+        var prefix = "[".concat(timestamp, "] [@thorprovider/adapters:").concat(namespace, "] ").concat(level.toUpperCase(), ":");
+        console[level].apply(console, __spreadArray([prefix, message], args, false));
+    };
+    return {
+        debug: function (message) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return log.apply(void 0, __spreadArray(['debug', message], args, false));
+        },
+        info: function (message) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return log.apply(void 0, __spreadArray(['info', message], args, false));
+        },
+        warn: function (message) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return log.apply(void 0, __spreadArray(['warn', message], args, false));
+        },
+        error: function (message) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return log.apply(void 0, __spreadArray(['error', message], args, false));
+        },
+    };
+}