1. /**
  2. * Guards execution of URL lists for backward compatibility with rate limiting.
  3. *
  4. * @param {string[]} urls An array of URLs to execute.
  5. * @param {function} rateLimitFunction A function that checks if rate limiting allows execution.
  6. * Should return true if allowed, false otherwise.
  7. * @param {number} [limit=10] The rate limit.
  8. * @param {number} [interval=1000] The interval between requests (in milliseconds).
  9. * @returns {Promise<void>} A promise that resolves when all URLs have been executed or rejected if rate limiting fails.
  10. * @throws {Error} If urls is not an array or rateLimitFunction is not a function.
  11. */
  12. async function guardUrlExecution(urls, rateLimitFunction, limit = 10, interval = 1000) {
  13. if (!Array.isArray(urls)) {
  14. throw new Error("urls must be an array.");
  15. }
  16. if (typeof rateLimitFunction !== 'function') {
  17. throw new Error("rateLimitFunction must be a function.");
  18. }
  20. let executedCount = 0;
  22. for (const url of urls) {
  23. if (!rateLimitFunction(executedCount, limit, interval)) {
  24. console.log(`Rate limit exceeded. Skipping URL: ${url}`);
  25. return; // Stop execution if rate limit is exceeded
  26. }
  28. try {
  29. // Simulate URL execution (replace with your actual logic)
  30. await executeUrl(url); // Replace with your URL execution logic
  31. executedCount++;
  33. console.log(`Executed URL: ${url}`);
  35. } catch (error) {
  36. console.error(`Error executing URL ${url}:`, error);
  37. // Handle errors as needed (e.g., retry, log, etc.)
  38. }
  39. }
  40. }
  42. /**
  43. * Simulates executing a URL. Replace with your actual URL execution logic.
  44. * @param {string} url The URL to execute.
  45. * @returns {Promise<void>} A promise that resolves when the URL is executed.
  46. */
  47. async function executeUrl(url) {
  48. return new Promise((resolve) => {
  49. setTimeout(() => {
  50. resolve();
  51. }, 500); // Simulate some work
  52. });
  53. }

Add your comment