remove unnecessary retry

Author: dillonstreator

README.md

@@ -80,7 +80,7 @@ await db.query("COMMIT");
 - ✅ **Configurable error handling** - Exponential backoff, max retries, and custom error hooks
 - ✅ **TypeScript-first** - Full type safety and autocompletion
 - ✅ **Handler result tracking** - Track the execution status of each handler independently
-- ✅ **Minimal dependencies** - Only `p-limit` and `retry` (plus your database driver)
+- ✅ **Minimal dependencies** - Only `p-limit` (plus your database driver)
 
 ## Quick Start
 
@@ -547,15 +547,6 @@ EventProcessor(client, handlerMap, {
   onEventMaxErrorsReached: async ({ event, txClient, signal }) => {
     // Create a dead-letter event, send alerts, etc.
   },
-
-  // Retry options for event update operations (default: shown below)
-  retryOpts: {
-    retries: 3,
-    factor: 2,
-    minTimeout: 100,
-    maxTimeout: 2500,
-    randomize: true,
-  },
 });
 ```
 
@@ -570,7 +561,6 @@ EventProcessor(client, handlerMap, {
 | `maxHandlerConcurrency`   | `number`                  | `10`        | Max handlers per event running concurrently |
 | `logger`                  | `Logger`                  | `undefined` | Custom logger interface                     |
 | `onEventMaxErrorsReached` | `function`                | `undefined` | Hook for max errors                         |
-| `retryOpts`               | `RetryOpts`               | See above   | Options for retrying event updates          |
 
 ## Usage Examples
 

package.json

@@ -58,8 +58,7 @@
     "format": "prettier -w ."
   },
   "dependencies": {
-    "p-limit": "^7.2.0",
-    "retry": "^0.13.1"
+    "p-limit": "^7.2.0"
   },
   "peerDependencies": {
     "mongodb": "^7.0.0",
@@ -69,7 +68,6 @@
     "@types/mongodb": "^4.0.7",
     "@types/node": "^25.0.3",
     "@types/pg": "^8.10.9",
-    "@types/retry": "^0.12.5",
     "@vitest/coverage-v8": "^4.0.15",
     "copyfiles": "^2.4.1",
     "mongodb": "^7.0.0",

src/processor.test.ts

@@ -55,10 +55,6 @@ describe("processEvents", () => {
     const opts = {
       maxErrors: 5,
       backoff: vi.fn(),
-      retry: {
-        minTimeout: 50,
-        maxTimeout: 100,
-      },
     };
     const err = new Error("some error");
     const handlerMap = {
@@ -124,11 +120,8 @@ describe("processEvents", () => {
 
       return events.find((e) => e.id === id);
     });
-    let updateEventCalls = 0;
     mockTxClient.updateEvent.mockImplementation(() => {
-      updateEventCalls++;
-      if (updateEventCalls <= 1) return Promise.reject("some error");
-      else return Promise.resolve();
+      return Promise.resolve();
     });
 
     await processEvents(mockClient, handlerMap, opts);
@@ -158,7 +151,7 @@ describe("processEvents", () => {
     expect(opts.backoff).toHaveBeenCalledOnce();
     expect(opts.backoff).toHaveBeenCalledWith(5); // evt.errors + 1
 
-    expect(mockTxClient.updateEvent).toHaveBeenCalledTimes(2);
+    expect(mockTxClient.updateEvent).toHaveBeenCalledTimes(1);
     expect(mockTxClient.updateEvent).toHaveBeenCalledWith({
       processed_at: now,
       backoff_until: null,

src/processor.ts

@@ -1,4 +1,3 @@
-import { type RetryOpts, retryable } from "./retry.js";
 import { getDate } from "./date.js";
 import EventEmitter from "node:events";
 import { sleep } from "./sleep.js";
@@ -81,7 +80,6 @@ const defaultMaxHandlerConcurrency = 10;
 type TxOBProcessEventsOpts<TxOBEventType extends string> = {
   maxErrors: number;
   backoff: (count: number) => Date;
-  retryOpts?: RetryOpts;
   signal?: AbortSignal;
   logger?: Logger;
   maxEventConcurrency?: number;
@@ -106,7 +104,6 @@ export const processEvents = async <TxOBEventType extends string>(
     logger,
     signal,
     onEventMaxErrorsReached,
-    retryOpts,
   } = opts ?? {};
 
   const events = await client.getEventsToProcess({ maxErrors, signal });
@@ -344,18 +341,7 @@ export const processEvents = async <TxOBEventType extends string>(
               "updating event",
             );
 
-            // The success of this update is crucial for the processor flow.
-            // In the unlikely scenario of a failure to update the event, any handlers that have succeeded
-            // during this iteration will be reinvoked in the subsequent processor tick.
-            // This is why the processor is guaranteed for 'at least once' processing.
-            await retryable(() => txClient.updateEvent(lockedEvent), {
-              retries: 3,
-              factor: 2,
-              minTimeout: 100,
-              maxTimeout: 2500,
-              randomize: true,
-              ...retryOpts,
-            });
+            await txClient.updateEvent(lockedEvent);
           });
         } catch (error) {
           logger?.error(