@trigger.dev/redis-worker 4.5.0 → 4.5.1

package/dist/index.cjs

@@ -9060,7 +9060,7 @@ var require_Redis = __commonJS({
     var lodash_1 = require_lodash3();
     var Deque = require_denque();
     var debug = (0, utils_1.Debug)("redis");
-    var Redis4 = class _Redis extends Commander_1.default {
+    var Redis3 = class _Redis extends Commander_1.default {
       constructor(arg1, arg2, arg3) {
         super();
         this.status = "wait";
@@ -9639,12 +9639,12 @@ var require_Redis = __commonJS({
         }).catch(lodash_1.noop);
       }
     };
-    Redis4.Cluster = cluster_1.default;
-    Redis4.Command = Command_1.default;
-    Redis4.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
-    (0, applyMixin_1.default)(Redis4, events_1.EventEmitter);
-    (0, transaction_1.addTransactionSupport)(Redis4.prototype);
-    exports$1.default = Redis4;
+    Redis3.Cluster = cluster_1.default;
+    Redis3.Command = Command_1.default;
+    Redis3.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
+    (0, applyMixin_1.default)(Redis3, events_1.EventEmitter);
+    (0, transaction_1.addTransactionSupport)(Redis3.prototype);
+    exports$1.default = Redis3;
   }
 });
 
@@ -12725,135 +12725,6 @@ return 1
     });
   }
 };
-var TenantDispatch = class {
-  constructor(options) {
-    this.options = options;
-    this.redis = createRedisClient(options.redis);
-    this.keys = options.keys;
-    this.shardCount = Math.max(1, options.shardCount);
-  }
-  redis;
-  keys;
-  shardCount;
-  /**
-   * Get the dispatch shard ID for a tenant.
-   * Uses jump consistent hash on the tenant ID so each tenant
-   * always maps to exactly one dispatch shard.
-   */
-  getShardForTenant(tenantId) {
-    return serverOnly.jumpHash(tenantId, this.shardCount);
-  }
-  /**
-   * Get eligible tenants from a dispatch shard (Level 1).
-   * Returns tenants ordered by oldest message (lowest score first).
-   */
-  async getTenantsFromShard(shardId, limit = 1e3, maxScore) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    const score = maxScore ?? Date.now();
-    const results = await this.redis.zrangebyscore(
-      dispatchKey,
-      "-inf",
-      score,
-      "WITHSCORES",
-      "LIMIT",
-      0,
-      limit
-    );
-    const tenants = [];
-    for (let i = 0; i < results.length; i += 2) {
-      const tenantId = results[i];
-      const scoreStr = results[i + 1];
-      if (tenantId && scoreStr) {
-        tenants.push({
-          tenantId,
-          score: parseFloat(scoreStr)
-        });
-      }
-    }
-    return tenants;
-  }
-  /**
-   * Get queues for a specific tenant (Level 2).
-   * Returns queues ordered by oldest message (lowest score first).
-   */
-  async getQueuesForTenant(tenantId, limit = 1e3, maxScore) {
-    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
-    const score = maxScore ?? Date.now();
-    const results = await this.redis.zrangebyscore(
-      tenantQueueKey,
-      "-inf",
-      score,
-      "WITHSCORES",
-      "LIMIT",
-      0,
-      limit
-    );
-    const queues = [];
-    for (let i = 0; i < results.length; i += 2) {
-      const queueId = results[i];
-      const scoreStr = results[i + 1];
-      if (queueId && scoreStr) {
-        queues.push({
-          queueId,
-          score: parseFloat(scoreStr),
-          tenantId
-        });
-      }
-    }
-    return queues;
-  }
-  /**
-   * Get the number of tenants in a dispatch shard.
-   */
-  async getShardTenantCount(shardId) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    return await this.redis.zcard(dispatchKey);
-  }
-  /**
-   * Get total tenant count across all dispatch shards.
-   * Note: tenants may appear in multiple shards, so this may overcount.
-   */
-  async getTotalTenantCount() {
-    const counts = await Promise.all(
-      Array.from({ length: this.shardCount }, (_, i) => this.getShardTenantCount(i))
-    );
-    return counts.reduce((sum, count) => sum + count, 0);
-  }
-  /**
-   * Get the number of queues for a tenant.
-   */
-  async getTenantQueueCount(tenantId) {
-    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
-    return await this.redis.zcard(tenantQueueKey);
-  }
-  /**
-   * Remove a tenant from a specific dispatch shard.
-   */
-  async removeTenantFromShard(shardId, tenantId) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    await this.redis.zrem(dispatchKey, tenantId);
-  }
-  /**
-   * Add a tenant to a dispatch shard with the given score.
-   */
-  async addTenantToShard(shardId, tenantId, score) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    await this.redis.zadd(dispatchKey, score, tenantId);
-  }
-  /**
-   * Remove a queue from a tenant's queue index.
-   */
-  async removeQueueFromTenant(tenantId, queueId) {
-    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
-    await this.redis.zrem(tenantQueueKey, queueId);
-  }
-  /**
-   * Close the Redis connection.
-   */
-  async close() {
-    await this.redis.quit();
-  }
-};
 
 // src/fair-queue/telemetry.ts
 var FairQueueAttributes = {
@@ -13368,6 +13239,135 @@ var noopSpan = {
   }
 };
 var noopTelemetry = new FairQueueTelemetry({});
+var TenantDispatch = class {
+  constructor(options) {
+    this.options = options;
+    this.redis = createRedisClient(options.redis);
+    this.keys = options.keys;
+    this.shardCount = Math.max(1, options.shardCount);
+  }
+  redis;
+  keys;
+  shardCount;
+  /**
+   * Get the dispatch shard ID for a tenant.
+   * Uses jump consistent hash on the tenant ID so each tenant
+   * always maps to exactly one dispatch shard.
+   */
+  getShardForTenant(tenantId) {
+    return serverOnly.jumpHash(tenantId, this.shardCount);
+  }
+  /**
+   * Get eligible tenants from a dispatch shard (Level 1).
+   * Returns tenants ordered by oldest message (lowest score first).
+   */
+  async getTenantsFromShard(shardId, limit = 1e3, maxScore) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    const score = maxScore ?? Date.now();
+    const results = await this.redis.zrangebyscore(
+      dispatchKey,
+      "-inf",
+      score,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      limit
+    );
+    const tenants = [];
+    for (let i = 0; i < results.length; i += 2) {
+      const tenantId = results[i];
+      const scoreStr = results[i + 1];
+      if (tenantId && scoreStr) {
+        tenants.push({
+          tenantId,
+          score: parseFloat(scoreStr)
+        });
+      }
+    }
+    return tenants;
+  }
+  /**
+   * Get queues for a specific tenant (Level 2).
+   * Returns queues ordered by oldest message (lowest score first).
+   */
+  async getQueuesForTenant(tenantId, limit = 1e3, maxScore) {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    const score = maxScore ?? Date.now();
+    const results = await this.redis.zrangebyscore(
+      tenantQueueKey,
+      "-inf",
+      score,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      limit
+    );
+    const queues = [];
+    for (let i = 0; i < results.length; i += 2) {
+      const queueId = results[i];
+      const scoreStr = results[i + 1];
+      if (queueId && scoreStr) {
+        queues.push({
+          queueId,
+          score: parseFloat(scoreStr),
+          tenantId
+        });
+      }
+    }
+    return queues;
+  }
+  /**
+   * Get the number of tenants in a dispatch shard.
+   */
+  async getShardTenantCount(shardId) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    return await this.redis.zcard(dispatchKey);
+  }
+  /**
+   * Get total tenant count across all dispatch shards.
+   * Note: tenants may appear in multiple shards, so this may overcount.
+   */
+  async getTotalTenantCount() {
+    const counts = await Promise.all(
+      Array.from({ length: this.shardCount }, (_, i) => this.getShardTenantCount(i))
+    );
+    return counts.reduce((sum, count) => sum + count, 0);
+  }
+  /**
+   * Get the number of queues for a tenant.
+   */
+  async getTenantQueueCount(tenantId) {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    return await this.redis.zcard(tenantQueueKey);
+  }
+  /**
+   * Remove a tenant from a specific dispatch shard.
+   */
+  async removeTenantFromShard(shardId, tenantId) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    await this.redis.zrem(dispatchKey, tenantId);
+  }
+  /**
+   * Add a tenant to a dispatch shard with the given score.
+   */
+  async addTenantToShard(shardId, tenantId, score) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    await this.redis.zadd(dispatchKey, score, tenantId);
+  }
+  /**
+   * Remove a queue from a tenant's queue index.
+   */
+  async removeQueueFromTenant(tenantId, queueId) {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    await this.redis.zrem(tenantQueueKey, queueId);
+  }
+  /**
+   * Close the Redis connection.
+   */
+  async close() {
+    await this.redis.quit();
+  }
+};
 var VisibilityManager = class {
   constructor(options) {
     this.options = options;
@@ -14349,6 +14349,101 @@ var CallbackFairQueueKeyProducer = class extends DefaultFairQueueKeyProducer {
     return this.groupExtractor(groupName, queueId);
   }
 };
+var ExponentialBackoffRetry = class {
+  maxAttempts;
+  options;
+  constructor(options) {
+    this.options = {
+      maxAttempts: options?.maxAttempts ?? 12,
+      factor: options?.factor ?? 2,
+      minTimeoutInMs: options?.minTimeoutInMs ?? 1e3,
+      maxTimeoutInMs: options?.maxTimeoutInMs ?? 36e5,
+      // 1 hour
+      randomize: options?.randomize ?? true
+    };
+    this.maxAttempts = this.options.maxAttempts ?? 12;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    const delay = v3.calculateNextRetryDelay(this.options, attempt);
+    return delay ?? null;
+  }
+};
+var FixedDelayRetry = class {
+  maxAttempts;
+  delayMs;
+  constructor(options) {
+    this.maxAttempts = options.maxAttempts;
+    this.delayMs = options.delayMs;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    return this.delayMs;
+  }
+};
+var LinearBackoffRetry = class {
+  maxAttempts;
+  baseDelayMs;
+  maxDelayMs;
+  constructor(options) {
+    this.maxAttempts = options.maxAttempts;
+    this.baseDelayMs = options.baseDelayMs;
+    this.maxDelayMs = options.maxDelayMs ?? options.baseDelayMs * options.maxAttempts;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    const delay = this.baseDelayMs * attempt;
+    return Math.min(delay, this.maxDelayMs);
+  }
+};
+var NoRetry = class {
+  maxAttempts = 1;
+  getNextDelay(_attempt, _error) {
+    return null;
+  }
+};
+var ImmediateRetry = class {
+  maxAttempts;
+  constructor(maxAttempts) {
+    this.maxAttempts = maxAttempts;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    return 0;
+  }
+};
+var CustomRetry = class {
+  maxAttempts;
+  calculateDelay;
+  constructor(options) {
+    this.maxAttempts = options.maxAttempts;
+    this.calculateDelay = options.calculateDelay;
+  }
+  getNextDelay(attempt, error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    return this.calculateDelay(attempt, error);
+  }
+};
+var defaultRetryOptions = {
+  maxAttempts: 12,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 36e5,
+  randomize: true
+};
+function createDefaultRetryStrategy() {
+  return new ExponentialBackoffRetry(defaultRetryOptions);
+}
 
 // src/fair-queue/scheduler.ts
 var BaseScheduler = class {
@@ -15121,101 +15216,6 @@ var RoundRobinScheduler = class extends BaseScheduler {
     return [...array.slice(normalizedIndex), ...array.slice(0, normalizedIndex)];
   }
 };
-var ExponentialBackoffRetry = class {
-  maxAttempts;
-  options;
-  constructor(options) {
-    this.options = {
-      maxAttempts: options?.maxAttempts ?? 12,
-      factor: options?.factor ?? 2,
-      minTimeoutInMs: options?.minTimeoutInMs ?? 1e3,
-      maxTimeoutInMs: options?.maxTimeoutInMs ?? 36e5,
-      // 1 hour
-      randomize: options?.randomize ?? true
-    };
-    this.maxAttempts = this.options.maxAttempts ?? 12;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    const delay = v3.calculateNextRetryDelay(this.options, attempt);
-    return delay ?? null;
-  }
-};
-var FixedDelayRetry = class {
-  maxAttempts;
-  delayMs;
-  constructor(options) {
-    this.maxAttempts = options.maxAttempts;
-    this.delayMs = options.delayMs;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    return this.delayMs;
-  }
-};
-var LinearBackoffRetry = class {
-  maxAttempts;
-  baseDelayMs;
-  maxDelayMs;
-  constructor(options) {
-    this.maxAttempts = options.maxAttempts;
-    this.baseDelayMs = options.baseDelayMs;
-    this.maxDelayMs = options.maxDelayMs ?? options.baseDelayMs * options.maxAttempts;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    const delay = this.baseDelayMs * attempt;
-    return Math.min(delay, this.maxDelayMs);
-  }
-};
-var NoRetry = class {
-  maxAttempts = 1;
-  getNextDelay(_attempt, _error) {
-    return null;
-  }
-};
-var ImmediateRetry = class {
-  maxAttempts;
-  constructor(maxAttempts) {
-    this.maxAttempts = maxAttempts;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    return 0;
-  }
-};
-var CustomRetry = class {
-  maxAttempts;
-  calculateDelay;
-  constructor(options) {
-    this.maxAttempts = options.maxAttempts;
-    this.calculateDelay = options.calculateDelay;
-  }
-  getNextDelay(attempt, error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    return this.calculateDelay(attempt, error);
-  }
-};
-var defaultRetryOptions = {
-  maxAttempts: 12,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 36e5,
-  randomize: true
-};
-function createDefaultRetryStrategy() {
-  return new ExponentialBackoffRetry(defaultRetryOptions);
-}
 
 // src/fair-queue/index.ts
 var FairQueue = class {