@profplum700/etsy-v3-api-client 2.3.1 → 2.3.9

package/dist/node.cjs

@@ -3,22 +3,40 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class EtsyApiError extends Error {
-    constructor(message, _statusCode, _response, _retryAfter) {
+    constructor(message, _statusCode, _response, _retryAfter, endpoint) {
         super(message);
         this._statusCode = _statusCode;
         this._response = _response;
         this._retryAfter = _retryAfter;
         this.name = 'EtsyApiError';
+        this.endpoint = endpoint;
+        this.timestamp = new Date();
         this.details = {
             statusCode: _statusCode || 0,
-            retryAfter: _retryAfter
+            retryAfter: _retryAfter,
+            endpoint,
+            timestamp: this.timestamp
         };
         if (_response && typeof _response === 'object') {
             const resp = _response;
             this.details.errorCode = (resp.error_code || resp.code);
             this.details.field = resp.field;
             this.details.suggestion = (resp.suggestion || resp.message);
+            if (Array.isArray(resp.errors)) {
+                this.details.validationErrors = resp.errors.map((err) => {
+                    if (err && typeof err === 'object') {
+                        const e = err;
+                        return {
+                            field: String(e.field || 'unknown'),
+                            message: String(e.message || 'Validation error')
+                        };
+                    }
+                    return { field: 'unknown', message: String(err) };
+                });
+            }
         }
+        this.suggestions = this.generateSuggestions();
+        this.docsUrl = this.generateDocsUrl();
     }
     get statusCode() {
         return this._statusCode;
@@ -51,6 +69,107 @@ class EtsyApiError extends Error {
         }
         return new Date(Date.now() + this._retryAfter * 1000);
     }
+    generateSuggestions() {
+        const suggestions = [];
+        if (!this._statusCode) {
+            return ['Check your network connection and try again'];
+        }
+        switch (this._statusCode) {
+            case 400:
+                suggestions.push('Review the Etsy API documentation for this endpoint');
+                suggestions.push('Check all required parameters are provided');
+                suggestions.push('Validate parameter formats and types');
+                if (this.details.validationErrors && this.details.validationErrors.length > 0) {
+                    suggestions.push('\nValidation errors:');
+                    this.details.validationErrors.forEach(err => {
+                        suggestions.push(`  • ${err.field}: ${err.message}`);
+                    });
+                }
+                if (this.details.field) {
+                    suggestions.push(`Field causing issue: ${this.details.field}`);
+                }
+                break;
+            case 401:
+                suggestions.push('Verify your access token is valid and not expired');
+                suggestions.push('Check if you need to refresh the token');
+                suggestions.push('Ensure you completed the OAuth flow correctly');
+                if (this.endpoint?.includes('/shops/')) {
+                    suggestions.push('Verify the shop_id matches the authenticated user');
+                }
+                break;
+            case 403:
+                suggestions.push('Check if your OAuth app has the required scopes:');
+                if (this.endpoint?.includes('/listings')) {
+                    suggestions.push('  • listings_r (for reading listings)');
+                    suggestions.push('  • listings_w (for creating/updating listings)');
+                }
+                if (this.endpoint?.includes('/receipts') || this.endpoint?.includes('/transactions')) {
+                    suggestions.push('  • transactions_r (for reading orders)');
+                }
+                if (this.endpoint?.includes('/shops')) {
+                    suggestions.push('  • shops_r (for reading shop data)');
+                    suggestions.push('  • shops_w (for updating shop data)');
+                }
+                suggestions.push('Verify your app is approved for production access');
+                suggestions.push('Check if the resource belongs to the authenticated user');
+                break;
+            case 404:
+                suggestions.push('Verify the resource ID exists and is spelled correctly');
+                if (this.endpoint?.includes('/listings/')) {
+                    suggestions.push('Check if the listing is active and not deleted');
+                    suggestions.push('Ensure the listing belongs to the authenticated shop');
+                }
+                if (this.endpoint?.includes('/shops/')) {
+                    suggestions.push('Verify the shop ID is correct');
+                }
+                if (this.endpoint?.includes('/receipts/')) {
+                    suggestions.push('Check if the receipt ID is valid');
+                    suggestions.push('Ensure you have access to this shop\'s receipts');
+                }
+                break;
+            case 409:
+                suggestions.push('Resource state conflict detected');
+                suggestions.push('Check if the resource was modified by another process');
+                suggestions.push('Try fetching the latest resource state before updating');
+                break;
+            case 429: {
+                const resetTime = this.getRateLimitReset();
+                const resetTimeStr = resetTime
+                    ? resetTime.toLocaleTimeString()
+                    : 'shortly';
+                suggestions.push(`Rate limit exceeded. Resets at ${resetTimeStr}`);
+                suggestions.push('Implement exponential backoff retry logic');
+                suggestions.push('Consider caching responses to reduce API calls');
+                suggestions.push('Check if you can batch multiple operations');
+                if (this._retryAfter) {
+                    suggestions.push(`Wait ${this._retryAfter} seconds before retrying`);
+                }
+                break;
+            }
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                suggestions.push('This is an Etsy server error, not your code');
+                suggestions.push('Retry the request after a short delay (exponential backoff)');
+                suggestions.push('Check Etsy API status: https://status.etsy.com');
+                if (this.isRetryable()) {
+                    suggestions.push('This error is retryable - the request can be safely retried');
+                }
+                break;
+            default:
+                suggestions.push('Check the Etsy API documentation for this endpoint');
+                suggestions.push('Review your request parameters and format');
+                if (this.details.suggestion) {
+                    suggestions.push(`Etsy suggestion: ${this.details.suggestion}`);
+                }
+        }
+        return suggestions;
+    }
+    generateDocsUrl() {
+        const errorCode = this.details.errorCode?.toLowerCase() || this._statusCode?.toString() || 'unknown';
+        return `https://github.com/profplum700/etsy-v3-api-client/blob/main/docs/troubleshooting/ERROR_CODES.md#${errorCode}`;
+    }
     getUserFriendlyMessage() {
         let message = this.message;
         if (this.details.suggestion) {
@@ -67,6 +186,46 @@ class EtsyApiError extends Error {
         }
         return message;
     }
+    toString() {
+        const parts = [
+            `EtsyApiError: ${this.message}`,
+            `Status Code: ${this._statusCode || 'Unknown'}`,
+        ];
+        if (this.details.errorCode) {
+            parts.push(`Error Code: ${this.details.errorCode}`);
+        }
+        if (this.endpoint) {
+            parts.push(`Endpoint: ${this.endpoint}`);
+        }
+        parts.push(`Timestamp: ${this.timestamp.toISOString()}`);
+        if (this.suggestions.length > 0) {
+            parts.push('\nSuggestions:');
+            this.suggestions.forEach(s => {
+                if (!s.startsWith('  •')) {
+                    parts.push(`  • ${s}`);
+                }
+                else {
+                    parts.push(s);
+                }
+            });
+        }
+        parts.push(`\nDocumentation: ${this.docsUrl}`);
+        return parts.join('\n');
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this._statusCode,
+            errorCode: this.details.errorCode,
+            endpoint: this.endpoint,
+            suggestions: this.suggestions,
+            docsUrl: this.docsUrl,
+            timestamp: this.timestamp.toISOString(),
+            details: this.details,
+            isRetryable: this.isRetryable(),
+        };
+    }
 }
 class EtsyAuthError extends Error {
     constructor(message, _code) {
@@ -1734,6 +1893,174 @@ const COMMON_SCOPE_COMBINATIONS = {
     ]
 };
 
+class GlobalRequestQueue {
+    constructor() {
+        this.queue = [];
+        this.processing = false;
+        this.rateLimits = new Map();
+        this.requestCount = 0;
+        this.dailyReset = new Date();
+        this.lastRequestTime = 0;
+        this.maxRequestsPerDay = 10000;
+        this.maxRequestsPerSecond = 10;
+        this.minRequestInterval = 100;
+        this.setNextDailyReset();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new GlobalRequestQueue();
+        }
+        return this.instance;
+    }
+    static resetInstance() {
+        this.instance = null;
+    }
+    async enqueue(request, options = {}) {
+        return new Promise((resolve, reject) => {
+            const queuedRequest = {
+                id: this.generateId(),
+                request,
+                resolve: resolve,
+                reject,
+                priority: options.priority ?? 'normal',
+                addedAt: Date.now(),
+                timeout: options.timeout ?? 30000,
+                endpoint: options.endpoint,
+            };
+            this.queue.push(queuedRequest);
+            if (!this.processing) {
+                this.processQueue().catch(error => {
+                    console.error('Queue processing error:', error);
+                });
+            }
+        });
+    }
+    getStatus() {
+        return {
+            queueLength: this.queue.length,
+            processing: this.processing,
+            remainingRequests: Math.max(0, this.maxRequestsPerDay - this.requestCount),
+            resetTime: this.dailyReset,
+        };
+    }
+    clear() {
+        this.queue.forEach(item => {
+            item.reject(new Error('Queue cleared'));
+        });
+        this.queue = [];
+    }
+    async processQueue() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        try {
+            while (this.queue.length > 0) {
+                if (Date.now() >= this.dailyReset.getTime()) {
+                    this.requestCount = 0;
+                    this.setNextDailyReset();
+                }
+                if (this.requestCount >= this.maxRequestsPerDay) {
+                    const timeUntilReset = this.dailyReset.getTime() - Date.now();
+                    console.warn(`Daily rate limit reached. Waiting ${Math.ceil(timeUntilReset / 1000 / 60)} minutes until reset.`);
+                    await this.delay(timeUntilReset);
+                    this.requestCount = 0;
+                    this.setNextDailyReset();
+                }
+                await this.waitForRateLimit();
+                this.queue.sort((a, b) => {
+                    const priorityOrder = {
+                        high: 0,
+                        normal: 1,
+                        low: 2,
+                    };
+                    return priorityOrder[a.priority] - priorityOrder[b.priority];
+                });
+                const item = this.queue.shift();
+                if (!item) {
+                    break;
+                }
+                const elapsed = Date.now() - item.addedAt;
+                if (item.timeout && elapsed > item.timeout) {
+                    item.reject(new Error(`Request timeout after ${elapsed}ms (exceeded while waiting in queue)`));
+                    continue;
+                }
+                try {
+                    let result;
+                    if (item.timeout) {
+                        const remainingTimeout = item.timeout - elapsed;
+                        const timeoutPromise = new Promise((_, reject) => {
+                            setTimeout(() => {
+                                reject(new Error(`Request timeout after ${item.timeout}ms (exceeded during execution)`));
+                            }, remainingTimeout);
+                        });
+                        result = await Promise.race([item.request(), timeoutPromise]);
+                    }
+                    else {
+                        result = await item.request();
+                    }
+                    item.resolve(result);
+                    this.requestCount++;
+                    this.lastRequestTime = Date.now();
+                }
+                catch (error) {
+                    if (error instanceof EtsyRateLimitError) {
+                        this.updateRateLimitInfo(error);
+                    }
+                    item.reject(error);
+                }
+                await this.delay(this.minRequestInterval);
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    async waitForRateLimit() {
+        const now = Date.now();
+        const globalRateLimit = this.rateLimits.get('global');
+        if (globalRateLimit && now < globalRateLimit.resetAt) {
+            const waitTime = globalRateLimit.resetAt - now;
+            console.log(`Global rate limit active. Waiting ${waitTime}ms`);
+            await this.delay(waitTime);
+        }
+        const timeSinceLastRequest = now - this.lastRequestTime;
+        if (timeSinceLastRequest < this.minRequestInterval) {
+            const waitTime = this.minRequestInterval - timeSinceLastRequest;
+            await this.delay(waitTime);
+        }
+    }
+    updateRateLimitInfo(error) {
+        const retryAfter = error.retryAfter;
+        if (retryAfter) {
+            this.rateLimits.set('global', {
+                remaining: 0,
+                resetAt: Date.now() + retryAfter * 1000,
+            });
+        }
+    }
+    setNextDailyReset() {
+        const now = new Date();
+        this.dailyReset = new Date(now);
+        this.dailyReset.setUTCDate(this.dailyReset.getUTCDate() + 1);
+        this.dailyReset.setUTCHours(0, 0, 0, 0);
+    }
+    generateId() {
+        return `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+GlobalRequestQueue.instance = null;
+function getGlobalQueue() {
+    return GlobalRequestQueue.getInstance();
+}
+function withQueue(request, options) {
+    const queue = GlobalRequestQueue.getInstance();
+    return queue.enqueue(request, options);
+}
+
 class PaginatedResults {
     constructor(fetcher, options = {}) {
         this.currentPage = [];
@@ -2803,6 +3130,403 @@ function createWebhookSecurity(secret, algorithm = 'sha256') {
     return new WebhookSecurity({ secret, algorithm });
 }
 
+class SecureTokenStorage {
+    constructor(config = {}) {
+        this.encryptionKey = null;
+        if (typeof window === 'undefined') {
+            throw new Error('SecureTokenStorage is only available in browser environments. ' +
+                'For Node.js, use EncryptedFileTokenStorage instead.');
+        }
+        if (!window.crypto || !window.crypto.subtle) {
+            throw new Error('Web Crypto API is not supported in this browser. ' +
+                'Please use a modern browser (Chrome 37+, Firefox 34+, Safari 11+, Edge 79+).');
+        }
+        this.keyPrefix = config.keyPrefix || 'etsy_token';
+        this.derivationInput = config.derivationInput || this.getDefaultDerivationInput();
+        this.storage = config.useSessionStorage ? sessionStorage : localStorage;
+    }
+    async save(tokens) {
+        const key = await this.getEncryptionKey();
+        const tokenJson = JSON.stringify(tokens);
+        const tokenData = new TextEncoder().encode(tokenJson);
+        const iv = window.crypto.getRandomValues(new Uint8Array(12));
+        const encrypted = await window.crypto.subtle.encrypt({
+            name: 'AES-GCM',
+            iv,
+        }, key, tokenData);
+        const integrity = await this.generateIntegrity(encrypted, iv);
+        const stored = {
+            version: 1,
+            encrypted: this.arrayBufferToBase64(encrypted),
+            iv: this.arrayBufferToBase64(iv),
+            integrity: this.arrayBufferToBase64(integrity),
+            expiresAt: tokens.expires_at.getTime(),
+            timestamp: Date.now(),
+        };
+        this.storage.setItem(this.keyPrefix, JSON.stringify(stored));
+    }
+    async load() {
+        const stored = this.storage.getItem(this.keyPrefix);
+        if (!stored) {
+            return null;
+        }
+        try {
+            const data = JSON.parse(stored);
+            if (data.version !== 1) {
+                console.warn('Unsupported token storage version. Clearing storage.');
+                await this.clear();
+                return null;
+            }
+            if (Date.now() > data.expiresAt) {
+                console.info('Stored tokens have expired. Clearing storage.');
+                await this.clear();
+                return null;
+            }
+            const encrypted = this.base64ToArrayBuffer(data.encrypted);
+            const iv = this.base64ToArrayBuffer(data.iv);
+            const storedIntegrity = this.base64ToArrayBuffer(data.integrity);
+            const computedIntegrity = await this.generateIntegrity(encrypted, iv);
+            if (!this.compareArrayBuffers(storedIntegrity, computedIntegrity)) {
+                console.warn('Token integrity check failed. Data may have been tampered with. Clearing storage.');
+                await this.clear();
+                return null;
+            }
+            const key = await this.getEncryptionKey();
+            const decrypted = await window.crypto.subtle.decrypt({
+                name: 'AES-GCM',
+                iv,
+            }, key, encrypted);
+            const tokenJson = new TextDecoder().decode(decrypted);
+            const tokens = JSON.parse(tokenJson);
+            tokens.expires_at = new Date(tokens.expires_at);
+            return tokens;
+        }
+        catch (error) {
+            console.error('Failed to load tokens from storage:', error);
+            await this.clear();
+            return null;
+        }
+    }
+    async clear() {
+        this.storage.removeItem(this.keyPrefix);
+    }
+    async getEncryptionKey() {
+        if (this.encryptionKey) {
+            return this.encryptionKey;
+        }
+        const keyMaterial = await this.deriveKeyMaterial();
+        this.encryptionKey = await window.crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            salt: this.stringToArrayBuffer('etsy-v3-api-client-salt'),
+            iterations: 100000,
+            hash: 'SHA-256',
+        }, keyMaterial, {
+            name: 'AES-GCM',
+            length: 256,
+        }, false, ['encrypt', 'decrypt']);
+        return this.encryptionKey;
+    }
+    async deriveKeyMaterial() {
+        const keyData = this.stringToArrayBuffer(this.derivationInput);
+        return window.crypto.subtle.importKey('raw', keyData, 'PBKDF2', false, ['deriveKey']);
+    }
+    async generateIntegrity(encrypted, iv) {
+        const combined = new Uint8Array(encrypted.byteLength + iv.byteLength);
+        combined.set(new Uint8Array(encrypted), 0);
+        combined.set(new Uint8Array(iv), encrypted.byteLength);
+        const keyMaterial = await this.deriveKeyMaterial();
+        const hmacKey = await window.crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            salt: this.stringToArrayBuffer('etsy-integrity-salt'),
+            iterations: 100000,
+            hash: 'SHA-256',
+        }, keyMaterial, {
+            name: 'HMAC',
+            hash: 'SHA-256',
+        }, false, ['sign']);
+        return window.crypto.subtle.sign('HMAC', hmacKey, combined);
+    }
+    getDefaultDerivationInput() {
+        const domain = window.location.hostname;
+        const userAgent = navigator.userAgent;
+        return `${domain}:${userAgent}`;
+    }
+    stringToArrayBuffer(str) {
+        return new TextEncoder().encode(str);
+    }
+    arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            const byte = bytes[i];
+            if (byte !== undefined) {
+                binary += String.fromCharCode(byte);
+            }
+        }
+        return btoa(binary);
+    }
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    compareArrayBuffers(a, b) {
+        if (a.byteLength !== b.byteLength) {
+            return false;
+        }
+        const viewA = new Uint8Array(a);
+        const viewB = new Uint8Array(b);
+        for (let i = 0; i < viewA.length; i++) {
+            if (viewA[i] !== viewB[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+function isSecureStorageSupported() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    return !!(window.crypto &&
+        window.crypto.subtle &&
+        typeof window.crypto.subtle.encrypt === 'function' &&
+        typeof window.crypto.subtle.decrypt === 'function' &&
+        typeof window.crypto.subtle.deriveKey === 'function');
+}
+
+class PluginManager {
+    constructor() {
+        this.plugins = [];
+    }
+    async register(plugin) {
+        if (this.plugins.some(p => p.name === plugin.name)) {
+            throw new Error(`Plugin with name "${plugin.name}" is already registered`);
+        }
+        this.plugins.push(plugin);
+        if (plugin.onInit) {
+            await plugin.onInit();
+        }
+    }
+    async unregister(pluginName) {
+        const index = this.plugins.findIndex(p => p.name === pluginName);
+        if (index === -1) {
+            return false;
+        }
+        const plugin = this.plugins[index];
+        if (!plugin) {
+            return false;
+        }
+        if (plugin.onDestroy) {
+            await plugin.onDestroy();
+        }
+        this.plugins.splice(index, 1);
+        return true;
+    }
+    getPlugins() {
+        return this.plugins;
+    }
+    getPlugin(name) {
+        return this.plugins.find(p => p.name === name);
+    }
+    async executeBeforeRequest(config) {
+        let currentConfig = config;
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeRequest) {
+                currentConfig = await plugin.onBeforeRequest(currentConfig);
+            }
+        }
+        return currentConfig;
+    }
+    async executeAfterResponse(response) {
+        let currentResponse = response;
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterResponse) {
+                currentResponse = await plugin.onAfterResponse(currentResponse);
+            }
+        }
+        return currentResponse;
+    }
+    async executeOnError(error) {
+        for (const plugin of this.plugins) {
+            if (plugin.onError) {
+                await plugin.onError(error);
+            }
+        }
+    }
+    async clear() {
+        for (const plugin of this.plugins) {
+            if (plugin.onDestroy) {
+                await plugin.onDestroy();
+            }
+        }
+        this.plugins = [];
+    }
+}
+function createAnalyticsPlugin(config) {
+    const requestTimes = new Map();
+    return {
+        name: 'analytics',
+        version: '1.0.0',
+        onBeforeRequest(requestConfig) {
+            const requestId = `${requestConfig.method}:${requestConfig.endpoint}:${Date.now()}`;
+            requestTimes.set(requestId, Date.now());
+            return requestConfig;
+        },
+        onAfterResponse(response) {
+            if (config.trackEndpoint) {
+                const requestId = Array.from(requestTimes.keys()).pop();
+                if (requestId) {
+                    const startTime = requestTimes.get(requestId);
+                    if (startTime) {
+                        const duration = Date.now() - startTime;
+                        const parts = requestId.split(':');
+                        const method = parts[0];
+                        const endpoint = parts[1];
+                        if (endpoint && method) {
+                            config.trackEndpoint(endpoint, method, duration);
+                        }
+                        requestTimes.delete(requestId);
+                    }
+                }
+            }
+            return response;
+        },
+        onError(error) {
+            if (config.trackError) {
+                config.trackError(error);
+            }
+        },
+    };
+}
+function createRetryPlugin(config = {}) {
+    const { retryableStatusCodes = [408, 429, 500, 502, 503, 504], } = config;
+    return {
+        name: 'retry',
+        version: '1.0.0',
+        async onError(error) {
+            if (error instanceof EtsyApiError) {
+                const statusCode = error.statusCode;
+                if (statusCode && retryableStatusCodes.includes(statusCode)) {
+                    if (config.onRetry) {
+                        config.onRetry(1, error);
+                    }
+                }
+            }
+        },
+    };
+}
+function createLoggingPlugin(config = {}) {
+    const logger = config.logger || console;
+    const logLevel = config.logLevel || 'info';
+    const shouldLog = (level) => {
+        const levels = ['debug', 'info', 'warn', 'error'];
+        const currentLevelIndex = levels.indexOf(logLevel);
+        const messageLevelIndex = levels.indexOf(level);
+        return messageLevelIndex >= currentLevelIndex;
+    };
+    return {
+        name: 'logging',
+        version: '1.0.0',
+        onBeforeRequest(requestConfig) {
+            if (shouldLog('debug')) {
+                logger.debug('[Etsy API] Request:', {
+                    method: requestConfig.method,
+                    endpoint: requestConfig.endpoint,
+                    params: requestConfig.params,
+                });
+            }
+            return requestConfig;
+        },
+        onAfterResponse(response) {
+            if (shouldLog('debug')) {
+                logger.debug('[Etsy API] Response:', {
+                    status: response.status,
+                    data: response.data,
+                });
+            }
+            return response;
+        },
+        onError(error) {
+            if (shouldLog('error')) {
+                logger.error('[Etsy API] Error:', error);
+                if (error instanceof EtsyApiError) {
+                    logger.error('[Etsy API] Error Details:', {
+                        statusCode: error.statusCode,
+                        endpoint: error.endpoint,
+                        suggestions: error.suggestions,
+                    });
+                }
+            }
+        },
+    };
+}
+function createCachingPlugin(config = {}) {
+    const cache = new Map();
+    const ttl = (config.ttl || 300) * 1000;
+    const generateKey = (requestConfig) => {
+        if (config.keyGenerator) {
+            return config.keyGenerator(requestConfig);
+        }
+        return `${requestConfig.method}:${requestConfig.endpoint}:${JSON.stringify(requestConfig.params || {})}`;
+    };
+    return {
+        name: 'caching',
+        version: '1.0.0',
+        onBeforeRequest(requestConfig) {
+            if (requestConfig.method.toUpperCase() === 'GET') {
+                const key = generateKey(requestConfig);
+                const cached = cache.get(key);
+                if (cached && Date.now() < cached.expiresAt) ;
+            }
+            return requestConfig;
+        },
+        onAfterResponse(response) {
+            const key = `GET:${response.status}`;
+            cache.set(key, {
+                data: response.data,
+                expiresAt: Date.now() + ttl,
+            });
+            return response;
+        },
+        onDestroy() {
+            cache.clear();
+        },
+    };
+}
+function createRateLimitPlugin(config = {}) {
+    const maxRequestsPerSecond = config.maxRequestsPerSecond || 10;
+    const requests = [];
+    return {
+        name: 'rateLimit',
+        version: '1.0.0',
+        async onBeforeRequest(requestConfig) {
+            const now = Date.now();
+            const oneSecondAgo = now - 1000;
+            while (requests.length > 0 && requests[0] !== undefined && requests[0] < oneSecondAgo) {
+                requests.shift();
+            }
+            if (requests.length >= maxRequestsPerSecond) {
+                if (config.onRateLimitExceeded) {
+                    config.onRateLimitExceeded();
+                }
+                const oldestRequest = requests[0];
+                if (oldestRequest !== undefined) {
+                    const waitTime = oldestRequest + 1000 - now;
+                    if (waitTime > 0) {
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                    }
+                }
+            }
+            requests.push(now);
+            return requestConfig;
+        },
+    };
+}
+
 function createEtsyClient(config) {
     return new EtsyClient(config);
 }
@@ -2845,6 +3569,7 @@ exports.EtsyRateLimiter = EtsyRateLimiter;
 exports.EtsyWebhookHandler = EtsyWebhookHandler;
 exports.FieldValidator = FieldValidator;
 exports.FileTokenStorage = FileTokenStorage;
+exports.GlobalRequestQueue = GlobalRequestQueue;
 exports.LFUCache = LFUCache;
 exports.LIBRARY_NAME = LIBRARY_NAME;
 exports.LRUCache = LRUCache;
@@ -2852,9 +3577,11 @@ exports.ListingQueryBuilder = ListingQueryBuilder;
 exports.LocalStorageTokenStorage = LocalStorageTokenStorage;
 exports.MemoryTokenStorage = MemoryTokenStorage;
 exports.PaginatedResults = PaginatedResults;
+exports.PluginManager = PluginManager;
 exports.ReceiptQueryBuilder = ReceiptQueryBuilder;
 exports.RedisCacheStorage = RedisCacheStorage;
 exports.RetryManager = RetryManager;
+exports.SecureTokenStorage = SecureTokenStorage;
 exports.SessionStorageTokenStorage = SessionStorageTokenStorage;
 exports.TokenManager = TokenManager;
 exports.UpdateListingSchema = UpdateListingSchema;
@@ -2864,19 +3591,24 @@ exports.ValidationException = ValidationException;
 exports.Validator = Validator;
 exports.WebhookSecurity = WebhookSecurity;
 exports.combineValidators = combineValidators;
+exports.createAnalyticsPlugin = createAnalyticsPlugin;
 exports.createAuthHelper = createAuthHelper;
 exports.createBatchQuery = createBatchQuery;
 exports.createBulkOperationManager = createBulkOperationManager;
 exports.createCacheStorage = createCacheStorage;
 exports.createCacheWithInvalidation = createCacheWithInvalidation;
+exports.createCachingPlugin = createCachingPlugin;
 exports.createCodeChallenge = createCodeChallenge;
 exports.createDefaultTokenStorage = createDefaultTokenStorage;
 exports.createEtsyClient = createEtsyClient;
 exports.createListingQuery = createListingQuery;
+exports.createLoggingPlugin = createLoggingPlugin;
 exports.createPaginatedResults = createPaginatedResults;
+exports.createRateLimitPlugin = createRateLimitPlugin;
 exports.createRateLimiter = createRateLimiter;
 exports.createReceiptQuery = createReceiptQuery;
 exports.createRedisCacheStorage = createRedisCacheStorage;
+exports.createRetryPlugin = createRetryPlugin;
 exports.createTokenManager = createTokenManager;
 exports.createValidator = createValidator;
 exports.createWebhookHandler = createWebhookHandler;
@@ -2894,16 +3626,19 @@ exports.generateRandomBase64Url = generateRandomBase64Url;
 exports.generateState = generateState;
 exports.getAvailableStorage = getAvailableStorage;
 exports.getEnvironmentInfo = getEnvironmentInfo;
+exports.getGlobalQueue = getGlobalQueue;
 exports.getLibraryInfo = getLibraryInfo;
 exports.hasLocalStorage = hasLocalStorage;
 exports.hasSessionStorage = hasSessionStorage;
 exports.isBrowser = isBrowser$1;
 exports.isNode = isNode$1;
+exports.isSecureStorageSupported = isSecureStorageSupported;
 exports.sha256 = sha256;
 exports.sha256Base64Url = sha256Base64Url;
 exports.validate = validate;
 exports.validateEncryptionKey = validateEncryptionKey;
 exports.validateOrThrow = validateOrThrow;
 exports.withQueryBuilder = withQueryBuilder;
+exports.withQueue = withQueue;
 exports.withRetry = withRetry;
 //# sourceMappingURL=node.cjs.map