@camunda8/orchestration-cluster-api 10.0.0-alpha.37 → 10.0.0-alpha.39

package/dist/effect/index.cjs

@@ -14156,7 +14156,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.37";
+var packageVersion = "10.0.0-alpha.39";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -15188,6 +15188,66 @@ var BackpressureManager = class {
   }
 };
 
+// src/runtime/clock.ts
+var SLEW_DIVISOR = 16;
+var MAX_TIMER_MS = 2147483647;
+function scheduleLong(ms, onElapsed) {
+  let remaining = Math.max(0, ms);
+  let timer;
+  const step = () => {
+    const slice = Math.min(remaining, MAX_TIMER_MS);
+    remaining -= slice;
+    timer = setTimeout(remaining > 0 ? step : onElapsed, slice);
+  };
+  step();
+  return () => clearTimeout(timer);
+}
+function createLiveClock(source = Date.now) {
+  let lastSource = source();
+  let offsetMs = 0;
+  let slewCreditMs = 0;
+  const now2 = () => {
+    const observed = source();
+    if (observed < lastSource) {
+      offsetMs += lastSource - observed;
+    } else if (offsetMs > 0) {
+      slewCreditMs += observed - lastSource;
+      const repay = Math.floor(slewCreditMs / SLEW_DIVISOR);
+      if (repay > 0) {
+        slewCreditMs -= repay * SLEW_DIVISOR;
+        offsetMs -= Math.min(offsetMs, repay);
+      }
+    }
+    lastSource = observed;
+    return observed + offsetMs;
+  };
+  const sleep2 = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const cancel = scheduleLong(ms, () => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    });
+    function onAbort() {
+      cancel();
+      reject(signal?.reason);
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  const deadline = (ms) => {
+    const controller = new AbortController();
+    const cancel = scheduleLong(
+      ms,
+      () => controller.abort(new DOMException(`Timed out after ${ms}ms`, "TimeoutError"))
+    );
+    return { signal: controller.signal, dispose: cancel };
+  };
+  return { now: now2, sleep: sleep2, deadline };
+}
+var liveClock = createLiveClock();
+
 // src/runtime/typedVariables.ts
 var TypedVariablesError = class extends Error {
   constructor(message, options) {
@@ -15421,6 +15481,51 @@ function nextActivationRetryDelayMs(attempt, cfg, rng) {
   return Number.isFinite(cfg.pollIntervalMs) ? Math.max(0, Math.round(cfg.pollIntervalMs)) : 0;
 }
 
+// src/runtime/workerGracefulStop.ts
+async function stopWorkerGracefully(deps, opts) {
+  const waitUpToMs = opts?.waitUpToMs ?? 5e3;
+  const checkIntervalMs = opts?.checkIntervalMs ?? 10;
+  deps.haltPolling();
+  const start = liveClock.now();
+  const inFlight = deps.inFlightActivation();
+  if (inFlight) {
+    const budget = liveClock.deadline(waitUpToMs);
+    try {
+      await Promise.race([
+        inFlight,
+        new Promise((_, rej) => {
+          const reject = () => rej(new Error("activation.wait.timeout"));
+          if (budget.signal.aborted) reject();
+          else budget.signal.addEventListener("abort", reject, { once: true });
+        })
+      ]);
+    } catch (e) {
+      if (e && e.message === "activation.wait.timeout") {
+        deps.log.debug("worker.gracefulStop.activationTimeout");
+      }
+    } finally {
+      budget.dispose();
+    }
+  }
+  while (deps.activeJobs() > 0 && liveClock.now() - start < waitUpToMs) {
+    await liveClock.sleep(checkIntervalMs);
+  }
+  const timedOut = deps.activeJobs() > 0;
+  if (timedOut) {
+    const pending = deps.inFlightActivation();
+    if (pending?.cancel) {
+      try {
+        pending.cancel();
+      } catch {
+      }
+    }
+    deps.log.debug("worker.gracefulStop.timeout", { remaining: deps.activeJobs() });
+  } else {
+    deps.log.debug("worker.gracefulStop.done");
+  }
+  return { remainingJobs: deps.activeJobs(), timedOut };
+}
+
 // src/runtime/workerStartGate.ts
 var WorkerStartGate = class {
   /**
@@ -15567,42 +15672,19 @@ var JobWorker = class {
    * If timeout is reached, falls back to hard stop logic (cancels activation if still pending).
    */
   async stopGracefully(opts) {
-    const waitUpToMs = opts?.waitUpToMs ?? 5e3;
-    const checkIntervalMs = opts?.checkIntervalMs ?? 10;
-    this._stopped = true;
-    if (this._pollTimer) clearTimeout(this._pollTimer);
-    this._pollTimer = null;
-    const start = Date.now();
-    if (this._inFlightActivation) {
-      try {
-        await Promise.race([
-          this._inFlightActivation,
-          new Promise(
-            (_, rej) => setTimeout(() => rej(new Error("activation.wait.timeout")), waitUpToMs)
-          )
-        ]);
-      } catch (e) {
-        if (e && e.message === "activation.wait.timeout") {
-          this._log.debug("worker.gracefulStop.activationTimeout");
-        }
-      }
-    }
-    while (this._activeJobs > 0 && Date.now() - start < waitUpToMs) {
-      await new Promise((r) => setTimeout(r, checkIntervalMs));
-    }
-    const timedOut = this._activeJobs > 0;
-    if (timedOut) {
-      if (this._inFlightActivation?.cancel) {
-        try {
-          this._inFlightActivation.cancel();
-        } catch {
-        }
-      }
-      this._log.debug("worker.gracefulStop.timeout", { remaining: this._activeJobs });
-    } else {
-      this._log.debug("worker.gracefulStop.done");
-    }
-    return { remainingJobs: this._activeJobs, timedOut };
+    return stopWorkerGracefully(
+      {
+        haltPolling: () => {
+          this._stopped = true;
+          if (this._pollTimer) clearTimeout(this._pollTimer);
+          this._pollTimer = null;
+        },
+        activeJobs: () => this._activeJobs,
+        inFlightActivation: () => this._inFlightActivation,
+        log: this._log
+      },
+      opts
+    );
   }
   _scheduleNext(delayMs) {
     if (this._stopped) return;
@@ -15895,42 +15977,19 @@ var ThreadedJobWorker = class {
     this._log.info("worker.stop");
   }
   async stopGracefully(opts) {
-    const waitUpToMs = opts?.waitUpToMs ?? 5e3;
-    const checkIntervalMs = opts?.checkIntervalMs ?? 10;
-    this._stopped = true;
-    if (this._pollTimer) clearTimeout(this._pollTimer);
-    this._pollTimer = null;
-    const start = Date.now();
-    if (this._inFlightActivation) {
-      try {
-        await Promise.race([
-          this._inFlightActivation,
-          new Promise(
-            (_, rej) => setTimeout(() => rej(new Error("activation.wait.timeout")), waitUpToMs)
-          )
-        ]);
-      } catch (e) {
-        if (e && e.message === "activation.wait.timeout") {
-          this._log.debug("worker.gracefulStop.activationTimeout");
-        }
-      }
-    }
-    while (this._activeJobs > 0 && Date.now() - start < waitUpToMs) {
-      await new Promise((r) => setTimeout(r, checkIntervalMs));
-    }
-    const timedOut = this._activeJobs > 0;
-    if (timedOut) {
-      if (this._inFlightActivation?.cancel) {
-        try {
-          this._inFlightActivation.cancel();
-        } catch {
-        }
-      }
-      this._log.debug("worker.gracefulStop.timeout", { remaining: this._activeJobs });
-    } else {
-      this._log.debug("worker.gracefulStop.done");
-    }
-    return { remainingJobs: this._activeJobs, timedOut };
+    return stopWorkerGracefully(
+      {
+        haltPolling: () => {
+          this._stopped = true;
+          if (this._pollTimer) clearTimeout(this._pollTimer);
+          this._pollTimer = null;
+        },
+        activeJobs: () => this._activeJobs,
+        inFlightActivation: () => this._inFlightActivation,
+        log: this._log
+      },
+      opts
+    );
   }
   // ─── Job dispatch ───
   _drainQueue() {
@@ -16607,6 +16666,7 @@ var CamundaClientBase = class {
   _validation = new ValidationManager({ req: "none", res: "none" });
   _log = createLogger();
   _bp;
+  _clock = liveClock;
   /** Registered job workers created via createJobWorker (lifecycle managed by user). */
   _workers = [];
   /** Shared thread pool for all threaded job workers (lazy-initialised on first use). */
@@ -16621,6 +16681,7 @@ var CamundaClientBase = class {
   _overrides = {};
   constructor(opts = {}) {
     if (opts.config) this._overrides = { ...opts.config };
+    this._clock = opts.clock ?? liveClock;
     const { config } = hydrateConfig({ overrides: this._overrides, env: opts.env });
     this._config = deepFreeze2(config);
     this._log = createLogger({
@@ -16693,6 +16754,8 @@ var CamundaClientBase = class {
     this.emitSupportLogPreamble();
     this._bp = new BackpressureManager({
       logger: this._log.scope("bp"),
+      now: () => this._clock.now(),
+      sleep: (ms) => this._clock.sleep(ms),
       config: {
         enabled: this._config.backpressure.enabled,
         observeOnly: this._config.backpressure.observeOnly,
@@ -16895,6 +16958,10 @@ var CamundaClientBase = class {
   _evaluateResponse(raw, opId, buildBackpressureError) {
     return evaluateSdkResponse(raw, { opId, buildBackpressureError });
   }
+  /** Clock backing SDK-internal cadence. The injected one when supplied, else the live clock. */
+  get clock() {
+    return this._clock;
+  }
   /** Public accessor for current backpressure adaptive limiter state (stable) */
   getBackpressureState() {
     try {
@@ -30999,6 +31066,36 @@ function toDomainError(err) {
   }
   return new CamundaGenericError({ message: String(err), cause: err });
 }
+function effectifyPaginate(search) {
+  return (body, opts = {}) => {
+    const { consistency, maxPages = Number.POSITIVE_INFINITY, mode = "auto" } = opts;
+    const pagesFrom = (pageBody, remaining, isFirstPage) => {
+      if (remaining <= 0) return import_effect.Stream.empty;
+      const consistencyArg = {
+        consistency: isFirstPage ? consistency ?? { waitUpToMs: 0 } : { waitUpToMs: 0 }
+      };
+      return import_effect.Stream.unwrap(
+        search(pageBody, consistencyArg).pipe(
+          import_effect.Effect.map((response) => {
+            const next = nextPageRequest(pageBody, response, mode);
+            const head = import_effect.Stream.make(response);
+            return next === null ? head : import_effect.Stream.concat(head, pagesFrom(next, remaining - 1, false));
+          })
+        )
+      );
+    };
+    const pages = () => pagesFrom(body, maxPages, true);
+    const items = () => pages().pipe(
+      import_effect.Stream.map((response) => response.items),
+      import_effect.Stream.flattenIterable
+    );
+    return {
+      pages,
+      items,
+      toArray: () => import_effect.Stream.runCollect(items()).pipe(import_effect.Effect.map((chunk) => [...chunk]))
+    };
+  };
+}
 function isPromiseLike(v) {
   return !!v && typeof v.then === "function";
 }
@@ -31006,7 +31103,7 @@ function createCamundaEffectClient(options) {
   const base = createCamundaClient(options);
   const cache = /* @__PURE__ */ new Map();
   function wrap(fn) {
-    return (...args) => import_effect.Effect.suspend(() => {
+    const wrapped = (...args) => import_effect.Effect.suspend(() => {
       let r;
       try {
         r = fn.apply(base, args);
@@ -31024,6 +31121,12 @@ function createCamundaEffectClient(options) {
         return typeof cancel === "function" ? import_effect.Effect.sync(() => cancel.call(r)) : void 0;
       });
     });
+    if (typeof fn.paginate === "function") {
+      wrapped.paginate = effectifyPaginate(
+        wrapped
+      );
+    }
+    return wrapped;
   }
   const handler = {
     get(_t, prop) {