Axios: добавление задержки между запросами

npm install axios-delay

import axios from 'axios';
import delayAdapterEnhancer from 'axios-delay';

const api = axios.create({
  adapter: delayAdapterEnhancer(axios.defaults.adapter),
  baseURL: 'https://api-seller.ozon.ru/',
  delay: 1000, // 1 секунда между запросами
  headers: {
    'Client-Id': process.env.OZON_CLIENT_ID,
    'Api-Key': process.env.OZON_API_KEY,
  },
});

// Теперь все запросы будут с задержкой
const products = await api.post('/v1/product/list', { page: 1 });
const details = await api.post('/v2/product/info', { product_id: 123 });

import axios from 'axios';

function createDelayedAxios(delayMs = 1000) {
  const instance = axios.create();
  let lastRequestTime = 0;

  instance.interceptors.request.use(async (config) => {
    const now = Date.now();
    const timeSinceLastRequest = now - lastRequestTime;
    
    if (timeSinceLastRequest < delayMs) {
      const waitTime = delayMs - timeSinceLastRequest;
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
    
    lastRequestTime = Date.now();
    return config;
  });

  return instance;
}

// Использование
const api = createDelayedAxios(1000);

await api.get('https://api.example.com/item/1');
await api.get('https://api.example.com/item/2'); // Автоматическая пауза 1 сек

class RequestQueue {
  constructor(requestsPerSecond = 1) {
    this.queue = [];
    this.processing = false;
    this.interval = 1000 / requestsPerSecond;
    this.lastRequestTime = 0;
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.processing || this.queue.length === 0) {
      return;
    }

    this.processing = true;

    while (this.queue.length > 0) {
      const now = Date.now();
      const timeSinceLastRequest = now - this.lastRequestTime;
      
      if (timeSinceLastRequest < this.interval) {
        await new Promise(r => setTimeout(r, this.interval - timeSinceLastRequest));
      }

      const { requestFn, resolve, reject } = this.queue.shift();
      
      try {
        this.lastRequestTime = Date.now();
        const result = await requestFn();
        resolve(result);
      } catch (error) {
        reject(error);
      }
    }

    this.processing = false;
  }
}

// Использование
const queue = new RequestQueue(1); // 1 запрос в секунду

const results = await Promise.all([
  queue.add(() => axios.get('/api/item/1')),
  queue.add(() => axios.get('/api/item/2')),
  queue.add(() => axios.get('/api/item/3')),
]);
// Запросы выполнятся последовательно с интервалом 1 сек

import axios from 'axios';

class OzonApiClient {
  constructor(clientId, apiKey, options = {}) {
    this.requestsPerSecond = options.requestsPerSecond || 1;
    this.lastRequestTime = 0;
    
    this.client = axios.create({
      baseURL: 'https://api-seller.ozon.ru/',
      headers: {
        'Client-Id': clientId,
        'Api-Key': apiKey,
        'Content-Type': 'application/json',
      },
      timeout: options.timeout || 30000,
    });

    // Добавляем задержку
    this.client.interceptors.request.use(async (config) => {
      await this.waitForRateLimit();
      return config;
    });

    // Обработка ошибок rate limit
    this.client.interceptors.response.use(
      response => response,
      async (error) => {
        if (error.response?.status === 429) {
          const retryAfter = error.response.headers['retry-after'] || 60;
          console.log(`Rate limit hit. Waiting ${retryAfter}s...`);
          await new Promise(r => setTimeout(r, retryAfter * 1000));
          return this.client.request(error.config);
        }
        throw error;
      }
    );
  }

  async waitForRateLimit() {
    const now = Date.now();
    const minInterval = 1000 / this.requestsPerSecond;
    const elapsed = now - this.lastRequestTime;
    
    if (elapsed < minInterval) {
      await new Promise(r => setTimeout(r, minInterval - elapsed));
    }
    
    this.lastRequestTime = Date.now();
  }

  async getProductList(page = 1, pageSize = 100) {
    const response = await this.client.post('/v1/product/list', {
      filter: { visibility: 'ALL' },
      page,
      page_size: pageSize,
    });
    return response.data.result;
  }

  async getProductInfo(productId) {
    const response = await this.client.post('/v2/product/info', {
      product_id: productId,
    });
    return response.data.result;
  }

  async getAllProducts() {
    const products = [];
    let page = 1;
    let hasMore = true;

    while (hasMore) {
      const result = await this.getProductList(page, 100);
      products.push(...result.items);
      
      hasMore = result.items.length === 100;
      page++;
      
      console.log(`Loaded ${products.length} products...`);
    }

    return products;
  }

  async getProductsWithDetails() {
    const list = await this.getAllProducts();
    const detailed = [];

    for (const item of list) {
      const info = await this.getProductInfo(item.product_id);
      detailed.push(info);
      console.log(`Details for ${item.product_id} loaded`);
    }

    return detailed;
  }
}

// Использование
const ozon = new OzonApiClient(
  process.env.OZON_CLIENT_ID,
  process.env.OZON_API_KEY,
  { requestsPerSecond: 0.8 } // Чуть меньше лимита для надёжности
);

const products = await ozon.getProductsWithDetails();
console.log(`Total: ${products.length} products`);

import pLimit from 'p-limit';

const limit = pLimit(5); // Максимум 5 параллельных запросов

const productIds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const results = await Promise.all(
  productIds.map(id => 
    limit(() => axios.get(`/api/products/${id}`))
  )
);