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

package/dist/index.cjs

@@ -1127,12 +1127,14 @@ function isInTimeRange(timestamp, timeRange) {
 
 // src/queries/adaptive-import.ts
 var import_deep_memory5 = require("@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);
@@ -1143,6 +1145,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,
@@ -1150,9 +1156,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;
@@ -1162,6 +1179,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;
@@ -1203,10 +1229,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);
     }
   }
@@ -1220,6 +1252,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) {
@@ -1228,6 +1261,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;
@@ -1408,7 +1450,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(