@haathie/pgmb 0.2.9 → 0.2.11

package/src/abortable-async-iterator.ts

@@ -1,98 +0,0 @@
-import assert from 'assert'
-
-type AAResult<T> = IteratorResult<T>
-
-export class AbortableAsyncIterator<T> implements AsyncIterableIterator<T> {
-	readonly signal: AbortSignal
-	readonly onEnd: () => void
-
-	ended = false
-
-	#resolve: (() => void) | undefined
-	#reject: ((reason?: unknown) => void) | undefined
-	#queue: T[] = []
-	#locked = false
-
-	constructor(signal: AbortSignal, onEnd: () => void = () => {}) {
-		this.signal = signal
-		this.onEnd = onEnd
-		signal.addEventListener('abort', this.#onAbort)
-	}
-
-	async next(): Promise<AAResult<T>> {
-		assert(!this.ended, 'Iterator has already been completed')
-		assert(!this.#locked, 'Concurrent calls to next() are not allowed')
-
-		let nextItem = this.#queue.shift()
-		if(nextItem) {
-			return { value: nextItem, done: false }
-		}
-
-		this.#locked = true
-		try {
-			await this.#setupNextPromise()
-		} finally {
-			this.#locked = false
-		}
-
-		nextItem = this.#queue.shift()
-		if(nextItem) {
-			return { value: nextItem, done: false }
-		}
-
-		return { value: undefined, done: true }
-	}
-
-	enqueue(value: T) {
-		assert(!this.ended, 'Iterator has already been completed')
-		this.#queue.push(value)
-		this.#resolve?.()
-	}
-
-	throw(reason?: unknown): Promise<AAResult<T>> {
-		this.signal.throwIfAborted()
-		this.#reject?.(reason)
-		this.#end()
-		return Promise.resolve({ done: true, value: undefined })
-	}
-
-	return(value?: any): Promise<AAResult<T>> {
-		this.#resolve?.()
-		this.#end()
-		return Promise.resolve({ done: true, value })
-	}
-
-	#setupNextPromise() {
-		return new Promise<void>((resolve, reject) => {
-			this.#resolve = () => {
-				resolve()
-				this.#cleanupTask()
-			}
-
-			this.#reject = err => {
-				reject(err)
-				this.#cleanupTask()
-			}
-		})
-	}
-
-	#cleanupTask() {
-		this.#resolve = undefined
-		this.#reject = undefined
-	}
-
-	#onAbort = (reason: any) => {
-		this.#reject?.(reason)
-		this.#end()
-		this.ended = true
-	}
-
-	#end() {
-		this.signal.removeEventListener('abort', this.#onAbort)
-		this.onEnd()
-	}
-
-	[Symbol.asyncIterator]() {
-		return this
-	}
-}

package/src/batcher.ts

@@ -1,90 +0,0 @@
-import type { IEventData, PGMBEventBatcherOpts } from './types.ts'
-
-type Batch<T> = {
-	messages: T[]
-}
-
-export class PGMBEventBatcher<T extends IEventData> {
-
-	#publish: PGMBEventBatcherOpts<T>['publish']
-	#flushIntervalMs: number | undefined
-	#maxBatchSize: number
-	#currentBatch: Batch<T> = { messages: [] }
-	#flushTimeout: NodeJS.Timeout | undefined
-	#flushTask: Promise<void> | undefined
-	#logger: PGMBEventBatcherOpts<T>['logger']
-	#shouldLog?: PGMBEventBatcherOpts<T>['shouldLog']
-	#batch = 0
-
-	constructor({
-		shouldLog,
-		publish,
-		flushIntervalMs,
-		maxBatchSize = 2500,
-		logger
-	}: PGMBEventBatcherOpts<T>) {
-		this.#publish = publish
-		this.#flushIntervalMs = flushIntervalMs
-		this.#maxBatchSize = maxBatchSize
-		this.#logger = logger
-		this.#shouldLog = shouldLog
-	}
-
-	async end() {
-		clearTimeout(this.#flushTimeout)
-		await this.#flushTask
-		await this.flush()
-	}
-
-	/**
-	 * Enqueue a message to be published, will be flushed to the database
-	 * when flush() is called (either manually or via interval)
-	 */
-	enqueue(msg: T) {
-		this.#currentBatch.messages.push(msg)
-		if(this.#currentBatch.messages.length >= this.#maxBatchSize) {
-			this.flush()
-			return
-		}
-
-		if(this.#flushTimeout || !this.#flushIntervalMs) {
-			return
-		}
-
-		this.#flushTimeout = setTimeout(() => this.flush(), this.#flushIntervalMs)
-	}
-
-	async flush() {
-		if(!this.#currentBatch.messages.length) {
-			return
-		}
-
-		const batch = this.#currentBatch
-		this.#currentBatch = { messages: [] }
-		clearTimeout(this.#flushTimeout)
-		this.#flushTimeout = undefined
-
-		await this.#flushTask
-
-		this.#flushTask = this.#publishBatch(batch)
-		return this.#flushTask
-	}
-
-	async #publishBatch({ messages }: Batch<T>) {
-		const batch = ++this.#batch
-		try {
-			const ids = await this.#publish(...messages)
-			for(const [i, { id }] of ids.entries()) {
-				if(this.#shouldLog && !this.#shouldLog(messages[i])) {
-					continue
-				}
-
-				this.#logger
-					?.info({ batch, id, message: messages[i] }, 'published message')
-			}
-		} catch(err) {
-			this.#logger
-				?.error({ batch, err, msgs: messages }, 'failed to publish messages')
-		}
-	}
-}