@rpcbase/worker 0.9.0 → 0.10.0

package/dist/index.js

@@ -109,7 +109,28 @@ const queueApi = {
 };
 const RETRY_MAXIMUM_DELAY_MS = 3e3;
 const RETRY_MINIMUM_DELAY_MS = 50;
-const sleep = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const RETRY_DEFAULT_FACTOR = 2;
+const sleep = async (ms, signal) => new Promise((resolve) => {
+  if (signal?.aborted) {
+    resolve();
+    return;
+  }
+  let timeout = null;
+  const cleanup = () => {
+    if (timeout) clearTimeout(timeout);
+    signal?.removeEventListener("abort", onAbort);
+  };
+  const onAbort = () => {
+    cleanup();
+    resolve();
+  };
+  timeout = setTimeout(() => {
+    cleanup();
+    resolve();
+  }, ms);
+  timeout.unref?.();
+  signal?.addEventListener("abort", onAbort);
+});
 const getMongoUrl = () => {
   const explicit = process.env.MONGODB_URL ?? process.env.MONGO_URL ?? process.env.MONGODB_URI ?? process.env.DB_URL;
   if (explicit && explicit.trim()) return explicit.trim();
@@ -162,19 +183,66 @@ const dispatchWorkerQueue = async ({
 const shouldSkipCollection = (collName) => collName.endsWith(".files") || collName.endsWith(".chunks");
 const INTERNAL_IGNORED_MODEL_NAMES = /* @__PURE__ */ new Set(["RBRtsChange", "RBRtsCounter"]);
 const INTERNAL_IGNORED_COLLECTION_NAMES = /* @__PURE__ */ new Set(["rtschanges", "rtscounters"]);
+const normalizeRetryDelays = (input) => {
+  const minMs = Math.max(0, Math.floor(input?.minMs ?? RETRY_MINIMUM_DELAY_MS));
+  const rawMaxMs = Math.max(0, Math.floor(input?.maxMs ?? RETRY_MAXIMUM_DELAY_MS));
+  const maxMs = Math.max(minMs, rawMaxMs);
+  const factor = Math.max(1, Number.isFinite(input?.factor) ? input?.factor ?? RETRY_DEFAULT_FACTOR : RETRY_DEFAULT_FACTOR);
+  return { minMs, maxMs, factor };
+};
+const getRetryDelayMs = (attempt, delays) => Math.min(delays.maxMs, Math.round(delays.minMs * Math.pow(delays.factor, Math.max(0, attempt - 1))));
+const normalizeMaxRetries = (value) => {
+  if (value === "infinite") return value;
+  const parsed = Math.floor(value);
+  return Number.isFinite(parsed) ? Math.max(0, parsed) : 0;
+};
 const registerQueueListener = async (options = {}) => {
-  const maxRetries = Math.max(1, Math.floor(options.maxRetries ?? 20));
+  const maxRetries = normalizeMaxRetries(options.maxRetries ?? "infinite");
+  const fatalOnMaxRetries = options.fatalOnMaxRetries ?? false;
+  const retryDelays = normalizeRetryDelays(options.retryDelays);
   const appName = process.env.APP_NAME?.trim();
   if (!appName) {
     throw new Error("Missing APP_NAME (required to configure the worker DB change listener)");
   }
   const mongoUrl = getMongoUrl();
+  const mongoClientOptions = {
+    family: 4,
+    serverSelectionTimeoutMS: 2e3,
+    connectTimeoutMS: 2e3,
+    ...options.mongoClientOptions
+  };
   let stopped = false;
-  let retryCounter = 0;
+  const abortController = new AbortController();
   let client = null;
   let stream = null;
   let resumeAfter = null;
   let processing = Promise.resolve();
+  let status = { state: "connecting", attempt: 1 };
+  const setStatus = (next) => {
+    status = next;
+    try {
+      options.onStateChange?.(next);
+    } catch (err) {
+      console.warn("queue listener onStateChange failed", err);
+    }
+  };
+  let readySettled = false;
+  let readyResolve = null;
+  let readyReject = null;
+  const ready = new Promise((resolve, reject) => {
+    readyResolve = resolve;
+    readyReject = reject;
+  });
+  const resolveReady = () => {
+    if (readySettled) return;
+    readySettled = true;
+    readyResolve?.();
+  };
+  const rejectReady = (err) => {
+    if (readySettled) return;
+    readySettled = true;
+    readyReject?.(err);
+  };
   const isChangeStreamHistoryLost = (err) => {
     const anyErr = err;
     const code = typeof anyErr?.code === "number" ? anyErr.code : null;
@@ -184,6 +252,24 @@ const registerQueueListener = async (options = {}) => {
   };
   const close2 = async () => {
     stopped = true;
+    abortController.abort();
+    try {
+      stream?.removeAllListeners();
+      await stream?.close();
+    } catch {
+    }
+    stream = null;
+    try {
+      await client?.close();
+    } catch {
+    }
+    client = null;
+    if (!readySettled) {
+      rejectReady(new Error("queue listener closed before ready"));
+    }
+    setStatus({ state: "closed" });
+  };
+  const closeResources = async () => {
     try {
       stream?.removeAllListeners();
       await stream?.close();
@@ -197,7 +283,7 @@ const registerQueueListener = async (options = {}) => {
     client = null;
   };
   const startStream = async () => {
-    if (stopped) return;
+    if (stopped) return { stoppedPromise: Promise.resolve({ reason: "close" }) };
     if (stream) {
       try {
         stream.removeAllListeners();
@@ -213,11 +299,7 @@ const registerQueueListener = async (options = {}) => {
       }
       client = null;
     }
-    client = new MongoClient(mongoUrl, {
-      family: 4,
-      serverSelectionTimeoutMS: 2e3,
-      connectTimeoutMS: 2e3
-    });
+    client = new MongoClient(mongoUrl, mongoClientOptions);
     await client.connect();
     const dbMatch = { "ns.db": { $regex: `^${escapeRegex(appName)}-.*-db$` } };
     const pipeline = [
@@ -233,6 +315,19 @@ const registerQueueListener = async (options = {}) => {
       fullDocument: "updateLookup",
       ...resumeAfter ? { resumeAfter } : {}
     });
+    const stoppedPromise = new Promise((resolve) => {
+      let settled = false;
+      const onAbort = () => settle({ reason: "close" });
+      const settle = (result) => {
+        if (settled) return;
+        settled = true;
+        abortController.signal.removeEventListener("abort", onAbort);
+        resolve(result);
+      };
+      abortController.signal.addEventListener("abort", onAbort);
+      stream?.once("close", () => settle({ reason: "close" }));
+      stream?.once("error", (err) => settle({ reason: "error", error: err }));
+    });
     stream.on("change", (change) => {
       const streamRef = stream;
       processing = processing.then(async () => {
@@ -274,33 +369,88 @@ const registerQueueListener = async (options = {}) => {
       });
     });
     stream.on("error", (err) => {
-      console.warn("queue listener change stream error", err);
       if (stopped) return;
       if (resumeAfter && isChangeStreamHistoryLost(err)) {
         resumeAfter = null;
       }
       try {
-        void stream?.close();
+        void Promise.resolve(stream?.close()).catch(() => {
+        });
       } catch {
       }
     });
-    stream.on("close", () => {
-      if (stopped) return;
-      retryCounter += 1;
-      if (retryCounter > maxRetries) {
-        console.error("queue listener reached max retries, exiting with failure");
-        process.exit(1);
+    return { stoppedPromise };
+  };
+  const run = async () => {
+    let retryCounter = 0;
+    while (!stopped) {
+      try {
+        setStatus({ state: "connecting", attempt: retryCounter + 1 });
+        const { stoppedPromise } = await startStream();
+        retryCounter = 0;
+        setStatus({ state: "ready" });
+        resolveReady();
+        const end = await stoppedPromise;
+        if (stopped) return;
+        retryCounter += 1;
+        if (maxRetries !== "infinite" && retryCounter > maxRetries) {
+          const err2 = end.reason === "error" ? end.error : new Error("queue listener closed");
+          setStatus({ state: "failed", attempt: retryCounter, error: err2 });
+          if (fatalOnMaxRetries) {
+            try {
+              options.onFatal?.(err2);
+            } catch (fatalErr) {
+              console.warn("queue listener onFatal failed", fatalErr);
+            }
+          }
+          rejectReady(err2);
+          abortController.abort();
+          await closeResources();
+          return;
+        }
+        const delayMs = getRetryDelayMs(retryCounter, retryDelays);
+        const err = end.reason === "error" ? end.error : new Error("queue listener closed");
+        console.warn("queue listener not ready, retrying in", delayMs, err);
+        setStatus({ state: "error", attempt: retryCounter, error: err, nextRetryInMs: delayMs });
+        await closeResources();
+        await sleep(delayMs, abortController.signal);
+      } catch (err) {
+        if (stopped) return;
+        retryCounter += 1;
+        if (maxRetries !== "infinite" && retryCounter > maxRetries) {
+          setStatus({ state: "failed", attempt: retryCounter, error: err });
+          if (fatalOnMaxRetries) {
+            try {
+              options.onFatal?.(err);
+            } catch (fatalErr) {
+              console.warn("queue listener onFatal failed", fatalErr);
+            }
+          }
+          rejectReady(err);
+          abortController.abort();
+          await closeResources();
+          return;
+        }
+        const delayMs = getRetryDelayMs(retryCounter, retryDelays);
+        console.warn("queue listener not ready, retrying in", delayMs, err);
+        setStatus({ state: "error", attempt: retryCounter, error: err, nextRetryInMs: delayMs });
+        await closeResources();
+        await sleep(delayMs, abortController.signal);
       }
-      const timeoutMs = Math.min(
-        RETRY_MAXIMUM_DELAY_MS,
-        RETRY_MINIMUM_DELAY_MS + 10 * Math.pow(2, retryCounter)
-      );
-      console.log("queue listener closed, retrying in", timeoutMs);
-      void sleep(timeoutMs).then(() => startStream());
-    });
+    }
+  };
+  const handle = {
+    ready,
+    close: close2,
+    getStatus: () => status
   };
-  await startStream();
-  return { close: close2 };
+  void run().catch(async (err) => {
+    if (stopped) return;
+    setStatus({ state: "failed", attempt: 0, error: err });
+    rejectReady(err);
+    await closeResources();
+  });
+  return handle;
 };
 const dbEventTaskName = (op, modelName) => `on-${op}-${modelName}`;
 export {

package/dist/queueListener.d.ts

@@ -1,9 +1,38 @@
-type Closeable = {
+import { MongoClientOptions } from 'mongodb';
+export type QueueListenerRetryDelays = {
+    minMs?: number;
+    maxMs?: number;
+    factor?: number;
+};
+export type QueueListenerStatus = {
+    state: "connecting";
+    attempt: number;
+} | {
+    state: "ready";
+} | {
+    state: "error";
+    attempt: number;
+    error: unknown;
+    nextRetryInMs: number;
+} | {
+    state: "failed";
+    attempt: number;
+    error: unknown;
+} | {
+    state: "closed";
+};
+export type QueueListenerHandle = {
+    ready: Promise<void>;
     close: () => Promise<void>;
+    getStatus: () => QueueListenerStatus;
 };
-type QueueListenerOptions = {
-    maxRetries?: number;
+export type QueueListenerOptions = {
+    maxRetries?: number | "infinite";
+    fatalOnMaxRetries?: boolean;
+    onStateChange?: (status: QueueListenerStatus) => void;
+    onFatal?: (err: unknown) => void;
+    retryDelays?: QueueListenerRetryDelays;
+    mongoClientOptions?: MongoClientOptions;
 };
-export declare const registerQueueListener: (options?: QueueListenerOptions) => Promise<Closeable>;
-export {};
+export declare const registerQueueListener: (options?: QueueListenerOptions) => Promise<QueueListenerHandle>;
 //# sourceMappingURL=queueListener.d.ts.map

package/dist/queueListener.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queueListener.d.ts","sourceRoot":"","sources":["../src/queueListener.ts"],"names":[],"mappings":"AAMA,KAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B,CAAA;AAED,KAAK,oBAAoB,GAAG;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AA4FD,eAAO,MAAM,qBAAqB,GAAU,UAAS,oBAAyB,KAAG,OAAO,CAAC,SAAS,CAsLjG,CAAA"}
+{"version":3,"file":"queueListener.d.ts","sourceRoot":"","sources":["../src/queueListener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiD,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAMhG,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAClB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACpD;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEvB,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;IACpB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,SAAS,EAAE,MAAM,mBAAmB,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAA;IACrD,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;IAChC,WAAW,CAAC,EAAE,wBAAwB,CAAA;IACtC,kBAAkB,CAAC,EAAE,kBAAkB,CAAA;CACxC,CAAA;AAuID,eAAO,MAAM,qBAAqB,GAAU,UAAS,oBAAyB,KAAG,OAAO,CAAC,mBAAmB,CA4T3G,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/worker",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "files": [
     "dist"