@speckle/objectloader2 2.26.2 → 2.26.4

package/src/queues/batchingQueue.test.ts

@@ -146,4 +146,125 @@ describe('BatchingQueue', () => {
       await queue.disposeAsync()
     }
   })
+
+  test('should handle processFunction throwing an exception during flush and is disposed', async () => {
+    const errorMessage = 'Process function failed'
+    const processFunction = vi.fn().mockRejectedValue(new Error(errorMessage))
+
+    const queue = new BatchingQueue<{ id: string }>({
+      batchSize: 5,
+      maxWaitTime: 1000,
+      processFunction
+    })
+
+    const items = Array.from({ length: 3 }, (_, i) => ({ id: `item-${i}` }))
+    items.forEach((item) => queue.add(item.id, item))
+
+    expect(queue.count()).toBe(3)
+
+    // flush should not throw even if processFunction rejects
+    await expect(queue.flush()).resolves.not.toThrow()
+
+    expect(processFunction).toHaveBeenCalled()
+    expect(queue.count()).toBe(0)
+    expect(queue.isDisposed()).toBe(false)
+    expect(queue.isErrored()).toBe(true)
+    // Add more items after the exception
+    queue.add('key3', { id: `item-3` })
+    queue.add('key4', { id: `item-4` })
+
+    // Wait to see if second batch gets processed (it shouldn't due to errored state)
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    expect(queue.count()).toBe(0) // Items were not added due to errored state
+    await queue.disposeAsync()
+  })
+
+  test('should drain remaining items when disposed', async () => {
+    const processSpy = vi.fn()
+    const queue = new BatchingQueue({
+      batchSize: 5, // Large batch size to prevent automatic processing
+      maxWaitTime: 10000, // Long timeout to prevent timeout-based processing
+      processFunction: async (batch: string[]): Promise<void> => {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        processSpy(batch)
+      }
+    })
+
+    // Add items that won't trigger automatic processing (less than batch size)
+    queue.add('key1', 'item1')
+    queue.add('key2', 'item2')
+    queue.add('key3', 'item3')
+
+    // Verify items are in queue but haven't been processed yet
+    expect(queue.count()).toBe(3)
+    expect(processSpy).not.toHaveBeenCalled()
+
+    // Dispose should drain the remaining items
+    await queue.disposeAsync()
+
+    // Verify all items were processed during disposal
+    expect(processSpy).toHaveBeenCalledTimes(1)
+    expect(processSpy).toHaveBeenCalledWith(['item1', 'item2', 'item3'])
+    expect(queue.count()).toBe(0)
+    expect(queue.isDisposed()).toBe(true)
+  })
+
+  test('should drain items even with ongoing processing during dispose', async () => {
+    const processSpy = vi.fn()
+    let firstBatchStarted = false
+    let allowFirstBatchToComplete: (() => void) | null = null
+
+    const queue = new BatchingQueue({
+      batchSize: 2,
+      maxWaitTime: 100,
+      processFunction: async (batch: string[]): Promise<void> => {
+        processSpy(batch)
+
+        // Make the first batch wait for our signal
+        if (!firstBatchStarted) {
+          firstBatchStarted = true
+          await new Promise<void>((resolve) => {
+            allowFirstBatchToComplete = resolve
+          })
+        } else {
+          // Other batches process normally
+          await new Promise((resolve) => setTimeout(resolve, 10))
+        }
+      }
+    })
+
+    // Add first batch that will trigger processing but will be blocked
+    queue.add('key1', 'item1')
+    queue.add('key2', 'item2')
+
+    // Wait for first batch to start processing and allowFirstBatchToComplete to be assigned
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    expect(firstBatchStarted).toBe(true)
+    expect(processSpy).toHaveBeenCalledTimes(1)
+    expect(allowFirstBatchToComplete).not.toBeNull()
+
+    // Add more items while first batch is still processing
+    queue.add('key3', 'item3')
+    queue.add('key4', 'item4')
+
+    // Verify the additional items are queued
+    expect(queue.count()).toBe(2)
+
+    // Start disposal (this should wait for ongoing processing and then drain)
+    const disposePromise = queue.disposeAsync()
+
+    // Allow the first batch to complete
+    allowFirstBatchToComplete!()
+
+    // Wait for disposal to complete
+    await disposePromise
+
+    // Verify all batches were processed
+    expect(processSpy).toHaveBeenCalledTimes(2)
+    expect(processSpy).toHaveBeenCalledWith(['item1', 'item2'])
+    expect(processSpy).toHaveBeenCalledWith(['item3', 'item4'])
+    expect(queue.count()).toBe(0)
+    expect(queue.isDisposed()).toBe(true)
+  })
 })

package/src/queues/batchingQueue.ts

@@ -11,9 +11,10 @@ export default class BatchingQueue<T> {
   #batchSize: number
   #processFunction: (batch: T[]) => Promise<void>
   #timeoutId: ReturnType<typeof setTimeout> | null = null
-  #isProcessing = false
 
-  #disposed = false
+  #isProcessing = false
+  #isDisposed = false
+  #isErrored = false
   #batchTimeout: number
 
   // Helper methods for cross-environment timeout handling
@@ -46,7 +47,8 @@ export default class BatchingQueue<T> {
   }
 
   async disposeAsync(): Promise<void> {
-    this.#disposed = true
+    if (this.#isDisposed) return
+    this.#isDisposed = true
     if (this.#timeoutId) {
       this.#getClearTimeoutFn()(this.#timeoutId)
       this.#timeoutId = null
@@ -62,56 +64,54 @@ export default class BatchingQueue<T> {
     // After any ongoing flush is completed, there might be items in the queue.
     // We should flush them.
     if (this.#queue.size > 0) {
-      await this.#flush()
+      await this.flush()
     }
   }
 
   add(key: string, item: T): void {
-    if (this.#disposed) return
+    if (this.#isDisposed || this.#isErrored) return
     this.#queue.enqueue(key, item)
     this.#addCheck()
   }
 
   addAll(keys: string[], items: T[]): void {
-    if (this.#disposed) return
+    if (this.#isDisposed || this.#isErrored) return
     this.#queue.enqueueAll(keys, items)
     this.#addCheck()
   }
 
   #addCheck(): void {
-    if (this.#disposed) return
+    if (this.#isDisposed) return
     if (this.#queue.size >= this.#batchSize) {
       // Fire and forget, no need to await
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.#flush()
+      this.flush()
     } else {
       if (this.#timeoutId) {
         this.#getClearTimeoutFn()(this.#timeoutId)
       }
       // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      this.#timeoutId = this.#getSetTimeoutFn()(() => this.#flush(), this.#batchTimeout)
+      this.#timeoutId = this.#getSetTimeoutFn()(() => this.flush(), this.#batchTimeout)
     }
   }
 
-  async #flush(): Promise<void> {
+  async flush(): Promise<void> {
     if (this.#timeoutId) {
       this.#getClearTimeoutFn()(this.#timeoutId)
       this.#timeoutId = null
     }
 
-    if (this.#isProcessing || this.#queue.size === 0) {
+    if (this.#isErrored || this.#isProcessing || this.#queue.size === 0) {
       return
     }
     this.#isProcessing = true
 
-    const batchToProcess = this.#getBatch(this.#batchSize)
-    if (this.#disposed) return
-
     try {
+      const batchToProcess = this.#getBatch(this.#batchSize)
       await this.#processFunction(batchToProcess)
     } catch (error) {
       console.error('Batch processing failed:', error)
-      this.#disposed = true
+      this.#isErrored = true
     } finally {
       this.#isProcessing = false
     }
@@ -127,7 +127,11 @@ export default class BatchingQueue<T> {
   }
 
   isDisposed(): boolean {
-    return this.#disposed
+    return this.#isDisposed
+  }
+
+  isErrored(): boolean {
+    return this.#isErrored
   }
 
   #getBatch(batchSize: number): T[] {