@whitewall/blip-sdk 0.0.138 → 0.0.140

package/src/sender/throttler.ts

@@ -1,36 +1,75 @@
 export class EnvelopeThrottler {
-    private sent = {
+    private buckets = {
         message: {
             max: 50,
-            started: 0,
-            count: 0,
+            tokens: 0,
+            lastRefill: 0,
+            waiting: [] as Array<() => void>,
+            timer: null as NodeJS.Timeout | null,
         },
         command: {
             max: 200,
-            started: 0,
-            count: 0,
+            tokens: 0,
+            lastRefill: 0,
+            waiting: [] as Array<() => void>,
+            timer: null as NodeJS.Timeout | null,
         },
     }
 
-    public async throttle(type: keyof typeof this.sent): Promise<void> {
-        const throughput = this.sent[type].max * 0.9
-        const timeToReset = 1000
+    private readonly refillInterval = 1000 // ms
+    private readonly throughputFactor = 0.9
+    // memo for fast-path (zero allocation)
+    private readonly voidPromise = Promise.resolve()
 
-        while (true) {
-            const elapsed = Date.now() - this.sent[type].started
+    public throttle(type: keyof typeof this.buckets): Promise<void> {
+        const bucket = this.buckets[type]
+        this.refillTokens(type)
 
-            if (elapsed >= timeToReset) {
-                this.sent[type].started = Date.now()
-                this.sent[type].count = 0
+        if (bucket.tokens > 0) {
+            bucket.tokens--
+            return this.voidPromise
+        }
+
+        const { resolve, promise } = Promise.withResolvers<void>()
+        bucket.waiting.push(resolve)
+
+        this.scheduleRefill(type)
+
+        return promise
+    }
+
+    private refillTokens(type: keyof typeof this.buckets): void {
+        const bucket = this.buckets[type]
+        const now = Date.now()
+        const elapsed = now - bucket.lastRefill
+
+        if (elapsed >= this.refillInterval) {
+            bucket.tokens = Math.floor(bucket.max * this.throughputFactor)
+            bucket.lastRefill = now
+        }
+    }
+
+    private scheduleRefill(type: keyof typeof this.buckets): void {
+        const bucket = this.buckets[type]
+        if (bucket.timer) return
+
+        const delay = Math.max(0, this.refillInterval - (Date.now() - bucket.lastRefill))
+
+        bucket.timer = setTimeout(() => {
+            bucket.timer = null
+            this.refillTokens(type)
+
+            while (bucket.tokens > 0 && bucket.waiting.length > 0) {
+                const resolve = bucket.waiting.shift()
+                if (resolve) {
+                    bucket.tokens--
+                    resolve()
+                }
             }
 
-            if (this.sent[type].count < throughput) {
-                this.sent[type].count++
-                break
-            } else {
-                const wait = timeToReset - elapsed
-                await new Promise((resolve) => setTimeout(resolve, wait))
+            if (bucket.waiting.length > 0) {
+                this.scheduleRefill(type)
             }
-        }
+        }, delay)
     }
 }

package/src/types/account.ts

@@ -82,3 +82,14 @@ export type Comment = {
     authorIdentity: Identity
     content: string
 }
+
+export type AccessKey = {
+    id: string
+    account: Identity
+    purpose?: string
+    expiration?: string
+    requirer: string
+    temporary: boolean
+    creationDate: string
+    key: string
+}