chore: surface rollback errors

Author: pepol

controlplane/src/core/blobstorage/dual.ts

@@ -26,16 +26,21 @@ export class DualBlobStorage implements BlobStorage {
       return;
     }
 
-    // Roll back successful writes before throwing
+    // Roll back successful writes before throwing, independent of the caller's signal
+    const rollbacks: Promise<void>[] = [];
     if (primaryResult.status === 'fulfilled') {
-      await this.primary.deleteObject({ key: data.key, abortSignal: data.abortSignal });
+      rollbacks.push(this.primary.deleteObject({ key: data.key }));
     }
     if (secondaryResult.status === 'fulfilled') {
-      await this.secondary.deleteObject({ key: data.key, abortSignal: data.abortSignal });
+      rollbacks.push(this.secondary.deleteObject({ key: data.key }));
     }
+    const rollbackResults = await Promise.allSettled(rollbacks);
 
-    const errors = results.filter((r): r is PromiseRejectedResult => r.status === 'rejected').map((r) => r.reason);
-    throw new AggregateError(errors, 'Failed to put object into storage');
+    const putErrors = results.filter((r): r is PromiseRejectedResult => r.status === 'rejected').map((r) => r.reason);
+    const rollbackErrors = rollbackResults
+      .filter((r): r is PromiseRejectedResult => r.status === 'rejected')
+      .map((r) => r.reason);
+    throw new AggregateError([...putErrors, ...rollbackErrors], 'Failed to put object into storage');
   }
 
   async getObject(data: { key: string; abortSignal?: AbortSignal }): Promise<BlobObject> {

controlplane/test/dual-blob-storage.test.ts

@@ -40,7 +40,7 @@ describe('DualBlobStorage', () => {
       });
 
       expect(primary.deleteObject).not.toHaveBeenCalled();
-      expect(secondary.deleteObject).toHaveBeenCalledWith({ key: 'k', abortSignal: undefined });
+      expect(secondary.deleteObject).toHaveBeenCalledWith({ key: 'k' });
     });
 
     test('rejects when secondary fails and rolls back primary', async () => {
@@ -56,9 +56,25 @@ describe('DualBlobStorage', () => {
         errors: [secondaryError],
       });
 
-      expect(primary.deleteObject).toHaveBeenCalledWith({ key: 'k', abortSignal: undefined });
+      expect(primary.deleteObject).toHaveBeenCalledWith({ key: 'k' });
       expect(secondary.deleteObject).not.toHaveBeenCalled();
     });
+    test('includes rollback errors in aggregate when rollback also fails', async () => {
+      const secondaryError = new Error('secondary write failed');
+      const rollbackError = new Error('primary rollback failed');
+      const primary = createMockBlobStorage({
+        deleteObject: vi.fn().mockRejectedValue(rollbackError),
+      });
+      const secondary = createMockBlobStorage({
+        putObject: vi.fn().mockRejectedValue(secondaryError),
+      });
+      const dual = new DualBlobStorage(primary, secondary);
+
+      await expect(dual.putObject({ key: 'k', body: Buffer.from('d'), contentType: 'text/plain' })).rejects.toMatchObject({
+        message: 'Failed to put object into storage',
+        errors: [secondaryError, rollbackError],
+      });
+    });
   });
 
   describe('getObject', () => {