1. class InputThrottler {
  2. constructor(limit = 5, interval = 1000) {
  3. this.limit = limit; // Maximum number of requests allowed within the interval
  4. this.interval = interval; // Time interval in milliseconds
  5. this.queue = []; // Queue to store pending requests
  6. this.running = false; // Flag to indicate if the throttler is running
  7. this.lastExecutionTime = 0; // Timestamp of the last execution
  8. }
  10. /**
  11. * Checks if a request is allowed based on the throttling rules.
  12. * @param {function} requestFunction - The function to be throttled.
  13. * @param {...any} args - Arguments to pass to the request function.
  14. * @returns {boolean} - True if the request is allowed, false otherwise.
  15. */
  16. isThrottled(requestFunction, ...args) {
  17. if (!this.running) {
  18. this.run();
  19. }
  21. // Check if the queue is full
  22. if (this.queue.length >= this.limit) {
  23. return false;
  24. }
  26. // Add the request to the queue
  27. this.queue.push({ function: requestFunction, args });
  28. return true;
  29. }
  32. /**
  33. * Executes the pending requests in the queue.
  34. */
  35. async run() {
  36. if (this.running) {
  37. return; // Prevent concurrent runs
  38. }
  40. this.running = true;
  41. const now = Date.now();
  43. // Clear the queue
  44. this.queue = [];
  46. for (let i = 0; i < this.queue.length; i++) {
  47. const { function: requestFunction, args } = this.queue[i];
  48. try {
  49. await requestFunction(...args);
  50. } catch (error) {
  51. console.error("Throttled request failed:", error);
  52. }
  53. }
  55. this.lastExecutionTime = now;
  56. this.running = false;
  58. // Schedule the next execution
  59. setTimeout(() => {
  60. this.run();
  61. }, this.interval);
  62. }
  64. /**
  65. * Sets the throttler to dry-run mode. Requests are logged but not executed.
  66. * @returns {boolean} - true if dry-run mode is enabled.
  67. */
  68. setDryRunMode(dryRun = true) {
  69. this.dryRun = dryRun;
  70. }
  72. /**
  73. * Returns the dry run status.
  74. * @returns {boolean} - dryRun status.
  75. */
  76. getDryRunMode() {
  77. return this.dryRun;
  78. }
  79. }
  81. // Example usage:
  82. // const throttler = new InputThrottler(3, 1000); // Limit 3 requests per 1 second
  84. // async function myRequest(data) {
  85. // console.log("Request executed with data:", data);
  86. // // Simulate an asynchronous operation
  87. // await new Promise(resolve => setTimeout(resolve, 200));
  88. // }
  90. // for (let i = 0; i < 10; i++) {
  91. // if (throttler.isThrottled(myRequest, `Data ${i}`)) {
  92. // console.log(`Request ${i} allowed`);
  93. // } else {
  94. // console.log(`Request ${i} throttled`);
  95. // }
  96. // }
  98. // throttler.setDryRunMode(true); //Enable dry run mode
  99. // for (let i = 0; i < 10; i++) {
  100. // if (throttler.isThrottled(myRequest, `Data ${i}`)) {
  101. // console.log(`Request ${i} allowed`);
  102. // } else {
  103. // console.log(`Request ${i} throttled`);
  104. // }
  105. // }

Add your comment