refactor: impl counter based event buffer

1. counter based event buffer keeps track of the number of blocks that request event processing in buffer
2. event buffer only releases events when the last block completes (i.e. counter = 0)

this approach is far simpler than the promised based garbled crap I wrote, should also prevent the deadlock issues it introduced 🙏

src/Utils/event-buffer.ts

@@ -21,8 +21,6 @@ const BUFFERABLE_EVENT = [
 	'groups.update',
 ] as const
 
-const BUFFER_TIMEOUT_MS = 60_000
-
 type BufferableEvent = typeof BUFFERABLE_EVENT[number]
 
 /**
@@ -41,15 +39,16 @@ type BaileysBufferableEventEmitter = BaileysEventEmitter & {
 	process(handler: (events: BaileysEventData) => void | Promise<void>): (() => void)
 	/**
 	 * starts buffering events, call flush() to release them
-	 * @returns true if buffering just started, false if it was already buffering
 	 * */
-	buffer(): boolean
+	buffer(): void
 	/** buffers all events till the promise completes */
 	createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>)
-	/** flushes all buffered events */
-	flush(): Promise<void>
-	/** waits for the task to complete, before releasing the buffer */
-	processInBuffer(task: Promise<any>)
+	/**
+	 * flushes all buffered events
+	 * @param force if true, will flush all data regardless of any pending buffers
+	 * @returns returns true if the flush actually happened, otherwise false
+	 */
+	flush(force?: boolean): boolean
 	/** is there an ongoing buffer */
 	isBuffering(): boolean
 }
@@ -64,14 +63,7 @@ export const makeEventBuffer = (logger: Logger): BaileysBufferableEventEmitter =
 	const historyCache = new Set<string>()
 
 	let data = makeBufferData()
-	let isBuffering = false
-	let preBufferTask: Promise<any> = Promise.resolve()
-
-	// debugging utils
-	let preBufferTraces: string[] = []
-	let bufferStartTrace: string | undefined
-	let bufferTimeout: NodeJS.Timeout | undefined
-	let waitingForPreBufferEnd = false
+	let buffersInProgress = 0
 
 	// take the generic event and fire it as a baileys event
 	ev.on('event', (map: BaileysEventData) => {
@@ -80,39 +72,25 @@ export const makeEventBuffer = (logger: Logger): BaileysBufferableEventEmitter =
 		}
 	})
 
-	function startTimeout() {
-		bufferTimeout = setTimeout(() => {
-			logger.warn(
-				{ preBufferTraces, bufferStartTrace, waitingForPreBufferEnd },
-				'event buffer taking a while'
-			)
-		}, BUFFER_TIMEOUT_MS)
-	}
-
 	function buffer() {
-		if(!isBuffering) {
-			logger.trace('buffering events')
-			isBuffering = true
-			startTimeout()
-			bufferStartTrace = new Error('buffer start').stack
-			return true
-		}
-
-		return false
+		buffersInProgress += 1
 	}
 
-	async function flush() {
-		if(!isBuffering) {
-			return
+	function flush(force = false) {
+		// no buffer going on
+		if(!buffersInProgress) {
+			return false
 		}
 
-		logger.trace({ preBufferTraces }, 'releasing buffered events...')
-		waitingForPreBufferEnd = true
-		await preBufferTask
-		waitingForPreBufferEnd = false
-
-		preBufferTraces = []
-		isBuffering = false
+		if(!force) {
+			// reduce the number of buffers in progress
+			buffersInProgress -= 1
+			// if there are still some buffers going on
+			// then we don't flush now
+			if(buffersInProgress) {
+				return false
+			}
+		}
 
 		const newData = makeBufferData()
 		const chatUpdates = Object.values(data.chatUpdates)
@@ -133,12 +111,12 @@ export const makeEventBuffer = (logger: Logger): BaileysBufferableEventEmitter =
 
 		data = newData
 
-		clearTimeout(bufferTimeout)
-
 		logger.trace(
 			{ conditionalChatUpdatesLeft },
 			'released buffered events'
 		)
+
+		return true
 	}
 
 	return {
@@ -153,40 +131,26 @@ export const makeEventBuffer = (logger: Logger): BaileysBufferableEventEmitter =
 			}
 		},
 		emit<T extends BaileysEvent>(event: BaileysEvent, evData: BaileysEventMap[T]) {
-			if(isBuffering && BUFFERABLE_EVENT_SET.has(event)) {
+			if(buffersInProgress && BUFFERABLE_EVENT_SET.has(event)) {
 				append(data, historyCache, event as any, evData, logger)
 				return true
 			}
 
 			return ev.emit('event', { [event]: evData })
 		},
-		processInBuffer(task) {
-			if(isBuffering) {
-				// if flushing right now,
-				// adding this won't make a difference
-				if(waitingForPreBufferEnd) {
-					return
-				}
-
-				preBufferTask = Promise.allSettled([ preBufferTask, task ])
-				preBufferTraces.push(new Error('').stack!)
-			}
-		},
 		isBuffering() {
-			return isBuffering
+			return buffersInProgress > 0
 		},
 		buffer,
 		flush,
 		createBufferedFunction(work) {
 			return async(...args) => {
-				const started = buffer()
+				buffer()
 				try {
 					const result = await work(...args)
 					return result
 				} finally {
-					if(started) {
-						await flush()
-					}
+					flush()
 				}
 			}
 		},