Rate Limits

class ThrottledVomoClient {
  constructor({ token, requestsPerSecond = 5 }) {
    this.token = token;
    this.requestsPerSecond = requestsPerSecond;
    this.queue = [];
    this.lastRequestAt = 0;
  }
 
  async request(url, options = {}) {
    await this._throttle();
 
    const response = await fetch(url, {
      ...options,
      headers: {
        Authorization: `Bearer ${this.token}`,
        Accept: 'application/json',
        ...options.headers,
      },
    });
 
    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 30 * 1000;
      await sleep(delayMs);
      return this.request(url, options); // Retry after backoff
    }
 
    return response;
  }
 
  async _throttle() {
    const minIntervalMs = 1000 / this.requestsPerSecond;
    const elapsed = Date.now() - this.lastRequestAt;
    if (elapsed < minIntervalMs) {
      await sleep(minIntervalMs - elapsed);
    }
    this.lastRequestAt = Date.now();
  }
}
 
function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

class TokenBucket {
  constructor({ capacity, refillPerSecond }) {
    this.capacity = capacity;
    this.tokens = capacity;
    this.refillPerSecond = refillPerSecond;
    this.lastRefillAt = Date.now();
  }
 
  async acquire() {
    while (true) {
      this._refill();
      if (this.tokens >= 1) {
        this.tokens -= 1;
        return;
      }
      const waitMs = ((1 - this.tokens) / this.refillPerSecond) * 1000;
      await sleep(waitMs);
    }
  }
 
  _refill() {
    const now = Date.now();
    const elapsedSec = (now - this.lastRefillAt) / 1000;
    this.tokens = Math.min(this.capacity, this.tokens + elapsedSec * this.refillPerSecond);
    this.lastRefillAt = now;
  }
}
 
const bucket = new TokenBucket({ capacity: 20, refillPerSecond: 10 });
 
async function rateLimitedRequest(url, options) {
  await bucket.acquire();
  return fetch(url, options);
}

async function request(url, options) {
  const start = Date.now();
  const response = await fetch(url, options);
  const latencyMs = Date.now() - start;
 
  metrics.timing('vomo.request.latency', latencyMs, { endpoint: simplifyUrl(url) });
 
  if (response.status === 429) {
    metrics.increment('vomo.request.rate_limited', { customerId });
    // Alert if this is sustained
  }
 
  return response;
}

// Direct request without throttling — fast for users
async function lookupUser(userId) {
  const response = await fetch(`https://api.vomo.org/v1/users/${userId}`, {
    headers: { Authorization: `Bearer ${token}` },
  });
 
  if (response.status === 429) {
    const retryAfter = parseInt(response.headers.get('Retry-After') ?? '5', 10);
    await sleep(retryAfter * 1000);
    return lookupUser(userId); // Single retry
  }
 
  if (!response.ok) throw new Error(`Lookup failed: ${response.status}`);
  return response.json();
}

async function pollUsersSync(customerId) {
  const client = new ThrottledVomoClient({ token, requestsPerSecond: 3 });
  const lastSync = await getCheckpoint(customerId);
 
  let url = `https://api.vomo.org/v1/users?updated_after=${encodeURIComponent(lastSync)}`;
 
  while (url) {
    const response = await client.request(url);
    const page = await response.json();
    await processUsers(customerId, page.data);
    url = page.links.next;
  }
 
  await advanceCheckpoint(customerId);
}
 
// Run on 15-minute interval
setInterval(() => pollUsersSync(customerId).catch(console.error), 15 * 60 * 1000);

async function backfillUsers(customerId) {
  const client = new ThrottledVomoClient({ token, requestsPerSecond: 2 });
  let url = 'https://api.vomo.org/v1/users';
 
  while (url) {
    const response = await client.request(url);
    const page = await response.json();
    await processUsers(customerId, page.data);
 
    console.log(`Backfill: ${page.meta.to}/${page.meta.total}`);
    url = page.links.next;
  }
}