fix(standard-server): batch signal (#353)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **Bug Fixes**
- Improved cancellation handling to gracefully manage empty or undefined
input scenarios, preventing potential errors.

- **Refactor**
- Streamlined the internal logic for managing cancellation events,
resulting in more robust and predictable behavior.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: unnoq

packages/standard-server/src/batch/signal.test.ts

@@ -1,22 +1,21 @@
 import { toBatchAbortSignal } from './signal'
 
 describe('toBatchAbortSignal', () => {
+  it('should return undefined if contains undefined or empty array', () => {
+    expect(toBatchAbortSignal([])).toBe(undefined)
+    expect(toBatchAbortSignal([undefined])).toBe(undefined)
+    expect(toBatchAbortSignal([AbortSignal.timeout(100), undefined])).toBe(undefined)
+    expect(toBatchAbortSignal([AbortSignal.timeout(100), undefined, AbortSignal.timeout(100)])).toBe(undefined)
+  })
+
   it('should return a non-aborted signal initially if not all inputs are aborted', () => {
     const controller1 = new AbortController()
     const controller2 = new AbortController()
 
-    // Case 1: Empty array
-    expect(toBatchAbortSignal([]).aborted).toBe(false)
-
-    // Case 2: Only undefined
-    expect(toBatchAbortSignal([undefined]).aborted).toBe(false)
-
-    // Case 3: No signals aborted
-    expect(toBatchAbortSignal([controller1.signal, controller2.signal]).aborted).toBe(false)
+    expect(toBatchAbortSignal([controller1.signal, controller2.signal])?.aborted).toBe(false)
 
-    // Case 4: Some signals aborted (but not all)
     controller1.abort()
-    expect(toBatchAbortSignal([controller1.signal, controller2.signal]).aborted).toBe(false)
+    expect(toBatchAbortSignal([controller1.signal, controller2.signal])?.aborted).toBe(false)
   })
 
   it('should return an aborted signal initially if all valid inputs are already aborted', () => {
@@ -25,8 +24,8 @@ describe('toBatchAbortSignal', () => {
     controller1.abort()
     controller2.abort()
 
-    const batchSignal = toBatchAbortSignal([controller1.signal, undefined, controller2.signal])
-    expect(batchSignal.aborted).toBe(true)
+    const batchSignal = toBatchAbortSignal([controller1.signal, controller2.signal])
+    expect(batchSignal?.aborted).toBe(true)
   })
 
   it('should fire abort event when all signals abort', () => {
@@ -38,22 +37,21 @@ describe('toBatchAbortSignal', () => {
 
     const batchSignal = toBatchAbortSignal([
       controllerPreAborted.signal,
-      undefined,
       controllerLater1.signal,
       controllerLater2.signal,
     ])
 
-    expect(batchSignal.aborted).toBe(false)
+    expect(batchSignal?.aborted).toBe(false)
 
     const abortSpy = vi.fn()
-    batchSignal.addEventListener('abort', abortSpy)
+    batchSignal?.addEventListener('abort', abortSpy)
 
     controllerLater1.abort()
-    expect(batchSignal.aborted).toBe(false)
+    expect(batchSignal?.aborted).toBe(false)
     expect(abortSpy).not.toHaveBeenCalled()
 
     controllerLater2.abort()
-    expect(batchSignal.aborted).toBe(true)
+    expect(batchSignal?.aborted).toBe(true)
     expect(abortSpy).toHaveBeenCalledTimes(1)
   })
 })

packages/standard-server/src/batch/signal.ts

@@ -1,21 +1,26 @@
-export function toBatchAbortSignal(signals: readonly (AbortSignal | undefined)[]): AbortSignal {
+export function toBatchAbortSignal(signals: readonly (AbortSignal | undefined)[]): AbortSignal | undefined {
   const realSignals = signals.filter(signal => signal !== undefined)
 
-  const controller = new AbortController()
+  if (realSignals.length === 0 || realSignals.length !== signals.length) {
+    return undefined
+  }
 
-  const abortedSignals = realSignals.filter(signal => signal.aborted)
+  const controller = new AbortController()
 
-  if (abortedSignals.length && abortedSignals.length === realSignals.length) {
-    controller.abort()
+  const abortIfAllInputsAborted = () => {
+    if (realSignals.every(signal => signal.aborted)) {
+      controller.abort()
+    }
   }
 
+  abortIfAllInputsAborted()
+
   for (const signal of realSignals) {
     signal.addEventListener('abort', () => {
-      abortedSignals.push(signal)
-
-      if (abortedSignals.length === realSignals.length) {
-        controller.abort()
-      }
+      abortIfAllInputsAborted()
+    }, {
+      once: true,
+      signal: controller.signal,
     })
   }