@ganaka/sdk 1.9.0 → 1.10.0

package/dist/index.js

@@ -8121,6 +8121,144 @@ const logger = pino({
     target: "pino-pretty"
   }
 });
+class RateLimiter {
+  constructor(config2) {
+    this.queue = [];
+    this.secondTimestamps = [];
+    this.minuteTimestamps = [];
+    this.processing = false;
+    this.inFlight = 0;
+    this.maxPerSecond = config2.maxPerSecond;
+    this.maxPerMinute = config2.maxPerMinute;
+    this.maxConcurrency = config2.maxConcurrency ?? 10;
+    this.requestTimeoutMs = config2.requestTimeoutMs ?? 3e4;
+  }
+  /**
+   * Execute a function with rate limiting.
+   * The function will be queued and executed when rate limits allow.
+   */
+  async execute(fn) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ execute: fn, resolve, reject });
+      this.processQueue();
+    });
+  }
+  /**
+   * Process the queue of pending requests.
+   * Dispatches requests concurrently up to maxConcurrency while respecting rate limits.
+   */
+  async processQueue() {
+    if (this.processing) {
+      return;
+    }
+    this.processing = true;
+    while (this.queue.length > 0) {
+      this.cleanupTimestamps();
+      if (this.inFlight < this.maxConcurrency && this.canMakeRequest()) {
+        const request = this.queue.shift();
+        if (!request) {
+          break;
+        }
+        const now = Date.now();
+        this.secondTimestamps.push(now);
+        this.minuteTimestamps.push(now);
+        this.inFlight++;
+        this.executeWithTimeout(request.execute, this.requestTimeoutMs).then((result) => {
+          request.resolve(result);
+        }).catch((error) => {
+          request.reject(error instanceof Error ? error : new Error(String(error)));
+        }).finally(() => {
+          this.inFlight--;
+          this.processQueue();
+        });
+      } else {
+        if (this.inFlight >= this.maxConcurrency) {
+          break;
+        } else {
+          const waitTime = this.getWaitTime();
+          if (waitTime > 0) {
+            await this.sleep(waitTime);
+          } else {
+            await this.sleep(10);
+          }
+        }
+      }
+    }
+    this.processing = false;
+  }
+  /**
+   * Check if a new request can be made based on current rate limits.
+   */
+  canMakeRequest() {
+    const now = Date.now();
+    const oneSecondAgo = now - 1e3;
+    const oneMinuteAgo = now - 6e4;
+    const recentSecondCount = this.secondTimestamps.filter((ts) => ts > oneSecondAgo).length;
+    const recentMinuteCount = this.minuteTimestamps.filter((ts) => ts > oneMinuteAgo).length;
+    return recentSecondCount < this.maxPerSecond && recentMinuteCount < this.maxPerMinute;
+  }
+  /**
+   * Remove timestamps that are outside the tracking windows.
+   */
+  cleanupTimestamps() {
+    const now = Date.now();
+    const oneSecondAgo = now - 1e3;
+    const oneMinuteAgo = now - 6e4;
+    this.secondTimestamps = this.secondTimestamps.filter((ts) => ts > oneSecondAgo);
+    this.minuteTimestamps = this.minuteTimestamps.filter((ts) => ts > oneMinuteAgo);
+  }
+  /**
+   * Calculate the minimum wait time needed before the next request can be made.
+   */
+  getWaitTime() {
+    const now = Date.now();
+    const oneSecondAgo = now - 1e3;
+    const oneMinuteAgo = now - 6e4;
+    let waitTime = 0;
+    const recentSecondCount = this.secondTimestamps.filter((ts) => ts > oneSecondAgo).length;
+    if (recentSecondCount >= this.maxPerSecond) {
+      const oldestInSecond = Math.min(...this.secondTimestamps.filter((ts) => ts > oneSecondAgo));
+      const waitForSecond = oldestInSecond + 1e3 - now;
+      waitTime = Math.max(waitTime, waitForSecond);
+    }
+    const recentMinuteCount = this.minuteTimestamps.filter((ts) => ts > oneMinuteAgo).length;
+    if (recentMinuteCount >= this.maxPerMinute) {
+      const oldestInMinute = Math.min(...this.minuteTimestamps.filter((ts) => ts > oneMinuteAgo));
+      const waitForMinute = oldestInMinute + 6e4 - now;
+      waitTime = Math.max(waitTime, waitForMinute);
+    }
+    return Math.max(waitTime, 0);
+  }
+  /**
+   * Execute a function with a timeout.
+   * If the function doesn't complete within the timeout, it will be rejected.
+   */
+  async executeWithTimeout(fn, timeoutMs) {
+    return Promise.race([
+      fn(),
+      new Promise(
+        (_2, reject) => setTimeout(
+          () => reject(new Error(`Request timed out after ${timeoutMs}ms`)),
+          timeoutMs
+        )
+      )
+    ]);
+  }
+  /**
+   * Sleep for a given number of milliseconds.
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+const limiters = /* @__PURE__ */ new Map();
+limiters.set("groww", new RateLimiter({
+  maxPerSecond: 10,
+  maxPerMinute: 300,
+  maxConcurrency: 10,
+  requestTimeoutMs: 3e4
+}));
+const growwRateLimiter = limiters.get("groww");
 dayjs.extend(utc);
 dayjs.extend(timezone);
 const fetchCandles = ({
@@ -8149,10 +8287,15 @@ const fetchCandles = ({
     if (currentTimezone) {
       headers["X-Current-Timezone"] = currentTimezone;
     }
-    const response = await axios.get(`${apiDomain}/v1/developer/historical-candles`, {
-      params: validatedParams,
-      headers
-    });
+    const response = await growwRateLimiter.execute(
+      () => axios.get(
+        `${apiDomain}/v1/developer/historical-candles`,
+        {
+          params: validatedParams,
+          headers
+        }
+      )
+    );
     return response.data.data;
   } catch (error) {
     if (axios.isAxiosError(error)) {