@utaba/deep-memory-storage-cosmosdb 0.12.0 → 0.12.1

package/dist/index.js

@@ -1090,12 +1090,14 @@ function isInTimeRange(timestamp, timeRange) {
 
 // src/queries/adaptive-import.ts
 import { ImportThrottleAbortError } from "@utaba/deep-memory";
-var DEFAULT_MIN = 2;
+var DEFAULT_MIN = 1;
 var DEFAULT_START = 5;
 var DEFAULT_MAX = 32;
 var DEFAULT_INCREASE_AFTER = 50;
 var DEFAULT_COOLDOWN_MS = 1e3;
 var DEFAULT_MAX_CONSECUTIVE_THROTTLES_AT_MIN = 10;
+var DEFAULT_THROTTLE_CEILING_MULTIPLIER = 3;
+var NO_SOFT_CEILING = Number.POSITIVE_INFINITY;
 function resolveOptions(opts) {
   const min = Math.max(1, opts?.min ?? DEFAULT_MIN);
   const max = Math.max(min, opts?.max ?? DEFAULT_MAX);
@@ -1106,6 +1108,10 @@ function resolveOptions(opts) {
     1,
     opts?.maxConsecutiveThrottlesAtMin ?? DEFAULT_MAX_CONSECUTIVE_THROTTLES_AT_MIN
   );
+  const throttleCeilingMultiplier = Math.max(
+    1,
+    opts?.throttleCeilingMultiplier ?? DEFAULT_THROTTLE_CEILING_MULTIPLIER
+  );
   return {
     min,
     start,
@@ -1113,9 +1119,20 @@ function resolveOptions(opts) {
     increaseAfter,
     cooldownMs,
     maxConsecutiveThrottlesAtMin,
+    throttleCeilingMultiplier,
     onAdjust: opts?.onAdjust
   };
 }
+function resolveController(options, handle) {
+  if (!handle) {
+    return new AdaptiveConcurrencyController(options);
+  }
+  const cosmosHandle = handle;
+  if (!cosmosHandle.controller) {
+    cosmosHandle.controller = new AdaptiveConcurrencyController(options);
+  }
+  return cosmosHandle.controller;
+}
 var AdaptiveConcurrencyController = class {
   opts;
   current;
@@ -1125,6 +1142,15 @@ var AdaptiveConcurrencyController = class {
   throttled = 0;
   startEmitted = false;
   consecutiveThrottlesAtMin = 0;
+  /**
+   * Highest concurrency at which a throttle has been observed and the
+   * controller actually halved (i.e. concrete evidence the cluster could not
+   * sustain that level). Re-approaching this level on subsequent ramp-ups
+   * requires `increaseAfter * throttleCeilingMultiplier` consecutive successes
+   * instead of just `increaseAfter`. Cleared once we've successfully held the
+   * level without further throttling — see noteSuccess.
+   */
+  softCeiling = NO_SOFT_CEILING;
   constructor(opts) {
     this.opts = resolveOptions(opts);
     this.current = this.opts.start;
@@ -1166,10 +1192,16 @@ var AdaptiveConcurrencyController = class {
     this.completed++;
     this.streak++;
     this.consecutiveThrottlesAtMin = 0;
-    if (this.streak >= this.opts.increaseAfter && this.current < this.opts.max) {
+    if (this.current >= this.opts.max) return;
+    const target = this.current + 1;
+    const needed = target >= this.softCeiling ? this.opts.increaseAfter * this.opts.throttleCeilingMultiplier : this.opts.increaseAfter;
+    if (this.streak >= needed) {
       const previous = this.current;
-      this.current = Math.min(this.opts.max, this.current + 1);
+      this.current = Math.min(this.opts.max, target);
       this.streak = 0;
+      if (this.current >= this.softCeiling) {
+        this.softCeiling = NO_SOFT_CEILING;
+      }
       this.notify("ramp-up", previous);
     }
   }
@@ -1183,6 +1215,7 @@ var AdaptiveConcurrencyController = class {
     this.cooldownUntil = now + this.opts.cooldownMs;
     if (next !== previous) {
       this.current = next;
+      this.softCeiling = previous;
       this.notify("throttle", previous);
     }
     if (this.current === this.opts.min) {
@@ -1191,6 +1224,15 @@ var AdaptiveConcurrencyController = class {
       this.consecutiveThrottlesAtMin = 0;
     }
   }
+  /**
+   * Current soft ceiling — the highest concurrency at which a throttle was
+   * observed and the controller halved. {@link Number.POSITIVE_INFINITY} when
+   * no ceiling is in effect. Re-approaching this level requires
+   * `increaseAfter * throttleCeilingMultiplier` consecutive successes.
+   */
+  getSoftCeiling() {
+    return this.softCeiling;
+  }
   /** Configured circuit-breaker threshold. */
   getMaxConsecutiveThrottlesAtMin() {
     return this.opts.maxConsecutiveThrottlesAtMin;
@@ -1371,7 +1413,7 @@ async function importBulk(conn, repositoryId, data, options) {
   let relationshipsImported = 0;
   const errors = [];
   const skipCheck = options?.skipExistenceCheck ?? false;
-  const controller = new AdaptiveConcurrencyController(options?.adaptiveConcurrency);
+  const controller = resolveController(options?.adaptiveConcurrency, options?.adaptiveConcurrencyHandle);
   for (const chunk of data) {
     if (chunk.entities && chunk.entities.length > 0) {
       const results = await runAdaptive(