راهنمای کامل برای پردازش محدودیت های سرعت API: از 429 خطا جلوگیری کنید

npm install express

npm install express

// Updated Test Server with Header Authentication
const express = require('express');
const app = express();
const PORT = 3001;

app.use(express.json());

// Profile keys for authentication
const validProfiles = {
  'profile-key-1': 'user1',
  'profile-key-2': 'user2', 
  'profile-key-3': 'user3'
};

// Simple in-memory rate limiting for profiles
const rateLimits = {
  'profile-key-1': [],
  'profile-key-2': [],
  'profile-key-3': []
};

const RATE_LIMIT = 5; // 5 requests per window
const WINDOW_MS = 10000; // 10 seconds

function checkRateLimit(profileKey) {
  const now = Date.now();
  
  if (!rateLimits[profileKey]) {
    rateLimits[profileKey] = [];
  }
  
  // Remove old requests outside the window
  rateLimits[profileKey] = rateLimits[profileKey].filter(time => now - time = RATE_LIMIT) {
    return false;
  }
  
  // Record this request
  rateLimits[profileKey].push(now);
  return true;
}

// Single POST endpoint that simulates social media posting
app.post('/api/post', (req, res) => {
  const { post, platforms = ['twitter'] } = req.body;
  const authHeader = req.headers['authorization'];
  const profileKey = req.headers['profile-key'];
  
  // Validate authentication header
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({
      success: false,
      message: 'Invalid authorization header. Expected: Bearer primary-profile-key'
    });
  }
  
  // Validate profile key
  if (!profileKey || !validProfiles[profileKey]) {
    return res.status(401).json({
      success: false,
      message: 'Invalid or missing profile-key header'
    });
  }
  
  // Validate post content
  if (!post) {
    return res.status(400).json({
      success: false,
      message: 'Post content is required'
    });
  }
  
  // Check rate limit for this profile
  if (!checkRateLimit(profileKey)) {
    return res.status(429).json({
      success: false,
      message: 'Rate limit exceeded',
      profileKey,
      retryAfter: 10
    });
  }
  
  // Simulate some processing delay
  setTimeout(() => {
    res.json({
      success: true,
      id: `post_${Date.now()}`,
      profileKey,
      post,
      platforms,
      timestamp: new Date().toISOString()
    });
  }, Math.random() * 500 + 200); // 200-700ms delay
});

app.listen(PORT, () => {
  console.log(`🚀 Header-Based Test Server running on http://localhost:${PORT}`);
  console.log(`📝 POST /api/post with headers:`);
  console.log(`   Authorization: Bearer primary-profile-key`);
  console.log(`   Profile-Key: profile-key-1|profile-key-2|profile-key-3`);
  console.log(`⏱️  Rate limit: 5 requests per 10 seconds per profile`);
});

// Updated Test Server with Header Authentication
const express = require('express');
const app = express();
const PORT = 3001;

app.use(express.json());

// Profile keys for authentication
const validProfiles = {
  'profile-key-1': 'user1',
  'profile-key-2': 'user2', 
  'profile-key-3': 'user3'
};

// Simple in-memory rate limiting for profiles
const rateLimits = {
  'profile-key-1': [],
  'profile-key-2': [],
  'profile-key-3': []
};

const RATE_LIMIT = 5; // 5 requests per window
const WINDOW_MS = 10000; // 10 seconds

function checkRateLimit(profileKey) {
  const now = Date.now();
  
  if (!rateLimits[profileKey]) {
    rateLimits[profileKey] = [];
  }
  
  // Remove old requests outside the window
  rateLimits[profileKey] = rateLimits[profileKey].filter(time => now - time WINDOW_MS);
  
  // Check if under limit
  if (rateLimits[profileKey].length >= RATE_LIMIT) {
    return false;
  }
  
  // Record this request
  rateLimits[profileKey].push(now);
  return true;
}

// Single POST endpoint that simulates social media posting
app.post('/api/post', (req, res) => {
  const { post, platforms = ['twitter'] } = req.body;
  const authHeader = req.headers['authorization'];
  const profileKey = req.headers['profile-key'];
  
  // Validate authentication header
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({
      success: false,
      message: 'Invalid authorization header. Expected: Bearer primary-profile-key'
    });
  }
  
  // Validate profile key
  if (!profileKey || !validProfiles[profileKey]) {
    return res.status(401).json({
      success: false,
      message: 'Invalid or missing profile-key header'
    });
  }
  
  // Validate post content
  if (!post) {
    return res.status(400).json({
      success: false,
      message: 'Post content is required'
    });
  }
  
  // Check rate limit for this profile
  if (!checkRateLimit(profileKey)) {
    return res.status(429).json({
      success: false,
      message: 'Rate limit exceeded',
      profileKey,
      retryAfter: 10
    });
  }
  
  // Simulate some processing delay
  setTimeout(() => {
    res.json({
      success: true,
      id: `post_${Date.now()}`,
      profileKey,
      post,
      platforms,
      timestamp: new Date().toISOString()
    });
  }, Math.random() * 500 + 200); // 200-700ms delay
});

app.listen(PORT, () => {
  console.log(`🚀 Header-Based Test Server running on http://localhost:${PORT}`);
  console.log(`📝 POST /api/post with headers:`);
  console.log(`   Authorization: Bearer primary-profile-key`);
  console.log(`   Profile-Key: profile-key-1|profile-key-2|profile-key-3`);
  console.log(`⏱️  Rate limit: 5 requests per 10 seconds per profile`);
});

node simple-test-server.js

node simple-test-server.js

class RateLimiter {
  constructor(maxRequests = 10, windowMs = 60000) {
    this.maxRequests = maxRequests;
    this.windowMs = windowMs;
    this.requests = [];
  }

  canMakeRequest() {
    const now = Date.now();
    // Remove requests outside the current window
    this.requests = this.requests.filter(time => now - time 

class RateLimiter {
  constructor(maxRequests = 10, windowMs = 60000) {
    this.maxRequests = maxRequests;
    this.windowMs = windowMs;
    this.requests = [];
  }

  canMakeRequest() {
    const now = Date.now();
    // Remove requests outside the current window
    this.requests = this.requests.filter(time => now - time this.windowMs);
    
    return this.requests.length this.maxRequests;
  }

  recordRequest() {
    this.requests.push(Date.now());
  }

  getWaitTime() {
    if (this.requests.length === 0) return 0;
    
    const oldestRequest = Math.min(...this.requests);
    const timeToWait = this.windowMs - (Date.now() - oldestRequest);
    return Math.max(0, timeToWait);
  }
}

class RateLimitedFetch {
  constructor(maxRequests = 10, windowMs = 60000) {
    this.limiter = new RateLimiter(maxRequests, windowMs);
  }

  async fetch(url, options = {}) {
    // Check if we can make the request
    if (!this.limiter.canMakeRequest()) {
      const waitTime = this.limiter.getWaitTime();
      console.log(`Rate limit exceeded. Waiting ${waitTime}ms...`);
      await this.sleep(waitTime);
    }

    // Record the request and make it
    this.limiter.recordRequest();
    return fetch(url, options);
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Example usage with headers
const rateLimitedFetch = new RateLimitedFetch(3, 5000); // 3 requests per 5 seconds

async function testBasicRateLimit() {
  try {
    for (let i = 0; i 

class RateLimitedFetch {
  constructor(maxRequests = 10, windowMs = 60000) {
    this.limiter = new RateLimiter(maxRequests, windowMs);
  }

  async fetch(url, options = {}) {
    // Check if we can make the request
    if (!this.limiter.canMakeRequest()) {
      const waitTime = this.limiter.getWaitTime();
      console.log(`Rate limit exceeded. Waiting ${waitTime}ms...`);
      await this.sleep(waitTime);
    }

    // Record the request and make it
    this.limiter.recordRequest();
    return fetch(url, options);
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Example usage with headers
const rateLimitedFetch = new RateLimitedFetch(3, 5000); // 3 requests per 5 seconds

async function testBasicRateLimit() {
  try {
    for (let i = 0; i 5; i++) {
      console.log(`Publishing post ${i + 1}...`);
      const response = await rateLimitedFetch.fetch('http://localhost:3001/api/post', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer primary-profile-key',
          'Profile-Key': 'profile-key-1'
        },
        body: JSON.stringify({
          post: `Test post ${i + 1} from rate limiter`,
          platforms: ['twitter', 'linkedin']
        })
      });
      console.log(`Post ${i + 1} response:`, response.status);
    }
  } catch (error) {
    console.error('Error:', error);
  }
}

testBasicRateLimit();

class FetchWithBackoff extends RateLimitedFetch {
  constructor(maxRequests = 10, windowMs = 60000, maxRetries = 3) {
    super(maxRequests, windowMs);
    this.maxRetries = maxRetries;
  }

  async fetch(url, options = {}) {
    let attempt = 0;
    
    while (attempt 

class FetchWithBackoff extends RateLimitedFetch {
  constructor(maxRequests = 10, windowMs = 60000, maxRetries = 3) {
    super(maxRequests, windowMs);
    this.maxRetries = maxRetries;
  }

  async fetch(url, options = {}) {
    let attempt = 0;
    
    while (attempt this.maxRetries) {
      try {
        // Check our local rate limit
        if (!this.limiter.canMakeRequest()) {
          const waitTime = this.limiter.getWaitTime();
          console.log(`Local rate limit: waiting ${waitTime}ms...`);
          await this.sleep(waitTime);
        }

        this.limiter.recordRequest();
        const response = await fetch(url, options);

        // Handle server-side rate limiting
        if (response.status === 429) {
          const retryAfter = response.headers.get('Retry-After');
          const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : this.getBackoffDelay(attempt);
          
          console.log(`Server rate limit (429): waiting ${waitTime}ms... (attempt ${attempt + 1})`);
          await this.sleep(waitTime);
          attempt++;
          continue;
        }

        return response;
      } catch (error) {
        if (attempt === this.maxRetries) {
          throw error;
        }
        
        const waitTime = this.getBackoffDelay(attempt);
        console.log(`Request failed: waiting ${waitTime}ms before retry... (attempt ${attempt + 1})`);
        await this.sleep(waitTime);
        attempt++;
      }
    }
    
    throw new Error(`Max retries (${this.maxRetries}) exceeded`);
  }

  getBackoffDelay(attempt) {
    // Exponential backoff: 1s, 2s, 4s, 8s...
    return Math.min(1000 * Math.pow(2, attempt), 30000); // Cap at 30 seconds
  }
}

// Example usage with headers
const fetchWithBackoff = new FetchWithBackoff(2, 5000, 3);

async function testFetchWithBackoff() {
  try {
    for (let i = 0; i 5; i++) {
      console.log(`Publishing fetch with backoff post ${i + 1}...`);
      const response = await fetchWithBackoff.fetch('http://localhost:3001/api/post', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer primary-profile-key',
          'Profile-Key': 'profile-key-1'
        },
        body: JSON.stringify({
          post: `Fetch with backoff test post ${i + 1}`,
          platforms: ['twitter']
        })
      });
      
      const result = await response.json();
      console.log(`Post ${i + 1} published successfully:`, result.id);
    }
  } catch (error) {
    console.error('Final error:', error.message);
  }
}

testFetchWithBackoff();

class MultiUserRateLimiter {
  constructor(maxRequestsPerProfile = 10, windowMs = 60000, maxRetries = 3) {
    this.maxRequestsPerProfile = maxRequestsPerProfile;
    this.windowMs = windowMs;
    this.maxRetries = maxRetries;
    
    // Store rate limiters per profile key
    this.profileLimiters = new Map();
  }

  getProfileLimiter(profileKey) {
    if (!this.profileLimiters.has(profileKey)) {
      // Create a FetchWithBackoff instance for each profile
      this.profileLimiters.set(profileKey, new FetchWithBackoff(this.maxRequestsPerProfile, this.windowMs, this.maxRetries));
    }
    return this.profileLimiters.get(profileKey);
  }

  async fetch(url, options = {}) {
    // Extract profile key from headers
    const profileKey = options.headers?.['Profile-Key'] || options.headers?.['profile-key'];
    
    if (!profileKey) {
      throw new Error('Profile-Key header is required for multi-user rate limiting');
    }

    // Get the profile's rate limiter and use it
    const profileLimiter = this.getProfileLimiter(profileKey);
    console.log(`Profile ${profileKey}: making request...`);
    
    return await profileLimiter.fetch(url, options);
  }

  // Utility methods for monitoring
  getProfileStatus(profileKey) {
    const limiter = this.profileLimiters.get(profileKey);

    if (!limiter) {
      return null;
    }

    return {
      profileKey,
      canMakeRequest: limiter.limiter.canMakeRequest(),
      requestsThisWindow: limiter.limiter.requests.length,
      waitTime: limiter.limiter.getWaitTime()
    };
  }

  getAllProfilesStatus() {
    const statuses = [];
    for (const profileKey of this.profileLimiters.keys()) {
      statuses.push(this.getProfileStatus(profileKey));
    }
    return statuses;
  }

  // Cleanup inactive profiles (optional)
  cleanupInactiveProfiles(inactiveThresholdMs = 300000) { // 5 minutes
    const now = Date.now();
    
    for (const [profileKey, fetchWithBackoff] of this.profileLimiters.entries()) {
      const limiter = fetchWithBackoff.limiter;
      const lastRequest = Math.max(...limiter.requests, 0);
      
      if (now - lastRequest > inactiveThresholdMs) {
        this.profileLimiters.delete(profileKey);
        console.log(`Cleaned up inactive profile: ${profileKey}`);
      }
    }
  }
}

// Example usage with multiple profiles
const multiUserRateLimiter = new MultiUserRateLimiter(3, 10000, 3); // 3 posts per 10 seconds per profile

async function testMultiUserRateLimit() {
  const profiles = [
    { key: 'profile-key-1', auth: 'Bearer primary-profile-key' },
    { key: 'profile-key-2', auth: 'Bearer primary-profile-key' },
    { key: 'profile-key-3', auth: 'Bearer primary-profile-key' }
  ];
  const promises = [];

  // Simulate multiple profiles publishing posts
  for (const profile of profiles) {
    for (let i = 0; i  response.json())
        .then(data => console.log(`${profile.key} - Post ${i + 1} published:`, data.id || 'Success'))
        .catch(error => console.error(`${profile.key} - Error:`, error.message))
      );
    }
  }

  // Monitor status
  console.log('Initial status:', multiUserRateLimiter.getAllProfilesStatus());
  
  try {
    await Promise.all(promises);
    console.log('All posts published successfully');
    console.log('Final status:', multiUserRateLimiter.getAllProfilesStatus());
  } catch (error) {
    console.error('Some posts failed:', error);
  }
}

testMultiUserRateLimit();

class MultiUserRateLimiter {
  constructor(maxRequestsPerProfile = 10, windowMs = 60000, maxRetries = 3) {
    this.maxRequestsPerProfile = maxRequestsPerProfile;
    this.windowMs = windowMs;
    this.maxRetries = maxRetries;
    
    // Store rate limiters per profile key
    this.profileLimiters = new Map();
  }

  getProfileLimiter(profileKey) {
    if (!this.profileLimiters.has(profileKey)) {
      // Create a FetchWithBackoff instance for each profile
      this.profileLimiters.set(profileKey, new FetchWithBackoff(this.maxRequestsPerProfile, this.windowMs, this.maxRetries));
    }
    return this.profileLimiters.get(profileKey);
  }

  async fetch(url, options = {}) {
    // Extract profile key from headers
    const profileKey = options.headers?.['Profile-Key'] || options.headers?.['profile-key'];
    
    if (!profileKey) {
      throw new Error('Profile-Key header is required for multi-user rate limiting');
    }

    // Get the profile's rate limiter and use it
    const profileLimiter = this.getProfileLimiter(profileKey);
    console.log(`Profile ${profileKey}: making request...`);
    
    return await profileLimiter.fetch(url, options);
  }

  // Utility methods for monitoring
  getProfileStatus(profileKey) {
    const limiter = this.profileLimiters.get(profileKey);

    if (!limiter) {
      return null;
    }

    return {
      profileKey,
      canMakeRequest: limiter.limiter.canMakeRequest(),
      requestsThisWindow: limiter.limiter.requests.length,
      waitTime: limiter.limiter.getWaitTime()
    };
  }

  getAllProfilesStatus() {
    const statuses = [];
    for (const profileKey of this.profileLimiters.keys()) {
      statuses.push(this.getProfileStatus(profileKey));
    }
    return statuses;
  }

  // Cleanup inactive profiles (optional)
  cleanupInactiveProfiles(inactiveThresholdMs = 300000) { // 5 minutes
    const now = Date.now();
    
    for (const [profileKey, fetchWithBackoff] of this.profileLimiters.entries()) {
      const limiter = fetchWithBackoff.limiter;
      const lastRequest = Math.max(...limiter.requests, 0);
      
      if (now - lastRequest > inactiveThresholdMs) {
        this.profileLimiters.delete(profileKey);
        console.log(`Cleaned up inactive profile: ${profileKey}`);
      }
    }
  }
}

// Example usage with multiple profiles
const multiUserRateLimiter = new MultiUserRateLimiter(3, 10000, 3); // 3 posts per 10 seconds per profile

async function testMultiUserRateLimit() {
  const profiles = [
    { key: 'profile-key-1', auth: 'Bearer primary-profile-key' },
    { key: 'profile-key-2', auth: 'Bearer primary-profile-key' },
    { key: 'profile-key-3', auth: 'Bearer primary-profile-key' }
  ];
  const promises = [];

  // Simulate multiple profiles publishing posts
  for (const profile of profiles) {
    for (let i = 0; i 5; i++) {
      promises.push(
        multiUserRateLimiter.fetch('http://localhost:3001/api/post', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'Authorization': profile.auth,
            'Profile-Key': profile.key
          },
          body: JSON.stringify({
            post: `Post ${i + 1} from ${profile.key} via rate limiter`,
            platforms: ['twitter', 'linkedin']
          })
        })
        .then(response => response.json())
        .then(data => console.log(`${profile.key} - Post ${i + 1} published:`, data.id || 'Success'))
        .catch(error => console.error(`${profile.key} - Error:`, error.message))
      );
    }
  }

  // Monitor status
  console.log('Initial status:', multiUserRateLimiter.getAllProfilesStatus());
  
  try {
    await Promise.all(promises);
    console.log('All posts published successfully');
    console.log('Final status:', multiUserRateLimiter.getAllProfilesStatus());
  } catch (error) {
    console.error('Some posts failed:', error);
  }
}

testMultiUserRateLimit();