mailery 0.1.2 → 0.2.2

package/dist/testing.cjs

@@ -4,7 +4,6 @@ var mongodb = require('mongodb');
 var crypto2 = require('crypto');
 var sgMail = require('@sendgrid/mail');
 var zod = require('zod');
-var bullmq = require('bullmq');
 var IORedis = require('ioredis');
 var Handlebars = require('handlebars');
 var htmlToText = require('html-to-text');
@@ -9500,10 +9499,10 @@ var require_dist2 = __commonJS({
         const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
         socket.write(`${payload}\r
 `);
-        const { connect, buffered } = await proxyResponsePromise;
-        req.emit("proxyConnect", connect);
-        this.emit("proxyConnect", connect, req);
-        if (connect.statusCode === 200) {
+        const { connect: connect2, buffered } = await proxyResponsePromise;
+        req.emit("proxyConnect", connect2);
+        this.emit("proxyConnect", connect2, req);
+        if (connect2.statusCode === 200) {
           req.once("socket", resume);
           if (opts.secureEndpoint) {
             debug("Upgrading socket connection to TLS");
@@ -14384,7 +14383,8 @@ async function ensureIndexes(db, prefix = "mailer_") {
       { key: { flowRunId: 1 }, sparse: true },
       { key: { broadcastId: 1 }, sparse: true },
       { key: { providerMessageId: 1 }, sparse: true },
-      { key: { status: 1, queuedAt: 1 } }
+      { key: { status: 1, queuedAt: 1 } },
+      { key: { status: 1, updatedAt: 1 } }
     ]),
     c.suppressions.createIndexes([
       { key: { email: 1, scope: 1 }, unique: true, partialFilterExpression: { email: { $type: "string" } } },
@@ -14476,6 +14476,104 @@ function signDoiToken(payload, secret) {
   const hmac = crypto2__default.default.createHmac("sha256", secret).update(bodyB64).digest();
   return `${bodyB64}.${b64url(hmac)}`;
 }
+var QUEUE_NAMES = {
+  tick: "mailer-tick",
+  advance: "mailer-advance",
+  send: "mailer-send",
+  webhook: "mailer-webhook"
+};
+var BullDriver = class _BullDriver {
+  queues;
+  redis;
+  bullQueues;
+  workers = null;
+  bull;
+  static async create(redisConfig) {
+    let bull;
+    try {
+      bull = await import('bullmq');
+    } catch {
+      throw new Error(
+        "mailery: queue driver 'bull' requires the 'bullmq' peer dependency. Run `npm install bullmq ioredis`."
+      );
+    }
+    const redis = isRedisLike(redisConfig) ? redisConfig : connect(redisConfig);
+    return new _BullDriver(bull, redis);
+  }
+  constructor(bull, redis) {
+    this.bull = bull;
+    this.redis = redis;
+    const opts = { connection: redis };
+    this.bullQueues = {
+      tick: new bull.Queue(QUEUE_NAMES.tick, opts),
+      advance: new bull.Queue(QUEUE_NAMES.advance, opts),
+      send: new bull.Queue(QUEUE_NAMES.send, opts),
+      webhook: new bull.Queue(QUEUE_NAMES.webhook, opts)
+    };
+    this.queues = {
+      tick: adaptBullQueue(this.bullQueues.tick),
+      advance: adaptBullQueue(this.bullQueues.advance),
+      send: adaptBullQueue(this.bullQueues.send),
+      webhook: adaptBullQueue(this.bullQueues.webhook)
+    };
+  }
+  async scheduleRepeatingTick(intervalSeconds) {
+    await this.bullQueues.tick.upsertJobScheduler(
+      "mailer-tick-repeat",
+      { every: intervalSeconds * 1e3 },
+      { name: "tick", data: {} }
+    );
+  }
+  async startWorkers(opts) {
+    if (this.workers) return;
+    const base = { connection: this.redis };
+    const { Worker } = this.bull;
+    const tick = new Worker(
+      QUEUE_NAMES.tick,
+      async (job) => opts.handlers.tick(job.data),
+      { ...base, concurrency: 1 }
+    );
+    const advance = new Worker(
+      QUEUE_NAMES.advance,
+      async (job) => opts.handlers.advance(job.data),
+      { ...base, concurrency: 10 }
+    );
+    const send = new Worker(
+      QUEUE_NAMES.send,
+      async (job) => opts.handlers.send(job.data),
+      {
+        ...base,
+        concurrency: opts.concurrency.send,
+        limiter: opts.sendRateLimit ? { max: opts.sendRateLimit.max, duration: opts.sendRateLimit.durationMs } : void 0
+      }
+    );
+    const webhook = new Worker(
+      QUEUE_NAMES.webhook,
+      async (job) => opts.handlers.webhook(job.data),
+      { ...base, concurrency: 4 }
+    );
+    this.workers = { tick, advance, send, webhook };
+  }
+  async stopWorkers() {
+    if (!this.workers) return;
+    await Promise.all([
+      this.workers.tick.close(),
+      this.workers.advance.close(),
+      this.workers.send.close(),
+      this.workers.webhook.close()
+    ]);
+    this.workers = null;
+  }
+  async close() {
+    await this.stopWorkers();
+    await Promise.all([
+      this.bullQueues.tick.close(),
+      this.bullQueues.advance.close(),
+      this.bullQueues.send.close(),
+      this.bullQueues.webhook.close()
+    ]);
+  }
+};
 function adaptBullQueue(q) {
   return {
     add: (name, data, opts) => q.add(name, data, opts),
@@ -14483,39 +14581,16 @@ function adaptBullQueue(q) {
     close: () => q.close()
   };
 }
-function noopQueueAPI() {
-  return {
-    add: async () => void 0,
-    getWaitingCount: async () => 0,
-    close: async () => void 0
-  };
-}
-function noopQueues() {
-  return {
-    tick: noopQueueAPI(),
-    advance: noopQueueAPI(),
-    send: noopQueueAPI(),
-    webhook: noopQueueAPI()
-  };
-}
-function namespacedQueueNames(prefix) {
-  return {
-    tick: "mailer-tick",
-    advance: "mailer-advance",
-    send: "mailer-send",
-    webhook: "mailer-webhook"
-  };
+function isRedisLike(x) {
+  return !!x && typeof x === "object" && typeof x.get === "function" && typeof x.set === "function";
 }
-function makeRedis(opts) {
-  if (isRedisLike(opts)) return opts;
+function connect(opts) {
   const config = {
     maxRetriesPerRequest: null,
     // BullMQ requirement
     enableReadyCheck: false
   };
-  if (opts.url) {
-    return new IORedis__default.default(opts.url, config);
-  }
+  if (opts.url) return new IORedis__default.default(opts.url, config);
   return new IORedis__default.default({
     ...config,
     host: opts.host ?? "127.0.0.1",
@@ -14526,69 +14601,198 @@ function makeRedis(opts) {
     tls: opts.tls ? {} : void 0
   });
 }
-function isRedisLike(x) {
-  return !!x && typeof x === "object" && typeof x.get === "function" && typeof x.set === "function";
-}
-function createQueues(redis) {
-  const names = namespacedQueueNames();
-  const qOpts = { connection: redis };
-  const bullQueues = {
-    tick: new bullmq.Queue(names.tick, qOpts),
-    advance: new bullmq.Queue(names.advance, qOpts),
-    send: new bullmq.Queue(names.send, qOpts),
-    webhook: new bullmq.Queue(names.webhook, qOpts)
-  };
+
+// src/server/queues/agenda.ts
+var QUEUE_NAMES2 = {
+  tick: "mailer-tick",
+  advance: "mailer-advance",
+  send: "mailer-send",
+  webhook: "mailer-webhook"
+};
+var AgendaDriver = class _AgendaDriver {
+  queues;
+  agenda;
+  agendaMod;
+  sendLimiter = null;
+  started = false;
+  static async create(opts) {
+    let agendaMod;
+    let backendMod;
+    try {
+      agendaMod = await import('agenda');
+      backendMod = await import('@agendajs/mongo-backend');
+    } catch {
+      throw new Error(
+        "mailery: queue driver 'agenda' requires the 'agenda' and '@agendajs/mongo-backend' peer dependencies. Run `npm install agenda @agendajs/mongo-backend bottleneck`."
+      );
+    }
+    const backend = new backendMod.MongoBackend({
+      mongo: opts.db,
+      collection: opts.collectionName ?? "_mailerJobs"
+    });
+    const agenda = new agendaMod.Agenda({
+      backend,
+      processEvery: `${opts.processEverySeconds ?? 5} seconds`,
+      defaultLockLifetime: (opts.lockLifetimeSeconds ?? 10 * 60) * 1e3,
+      maxConcurrency: 50,
+      defaultConcurrency: 5
+    });
+    return new _AgendaDriver(agenda, agendaMod, opts.db);
+  }
+  db;
+  constructor(agenda, agendaMod, db) {
+    this.agenda = agenda;
+    this.agendaMod = agendaMod;
+    this.db = db;
+    this.queues = {
+      tick: this.makeQueueAPI(QUEUE_NAMES2.tick),
+      advance: this.makeQueueAPI(QUEUE_NAMES2.advance),
+      send: this.makeQueueAPI(QUEUE_NAMES2.send),
+      webhook: this.makeQueueAPI(QUEUE_NAMES2.webhook)
+    };
+  }
+  makeQueueAPI(name) {
+    return {
+      add: async (_jobName, data, opts) => {
+        const payload = { ...data };
+        if (opts?.jobId) {
+          payload.__jobId = opts.jobId;
+          if (await this.findPending(name, opts.jobId)) return;
+        }
+        const job = this.agenda.create(name, payload);
+        if (opts?.delay) job.schedule(new Date(Date.now() + opts.delay));
+        await job.save();
+      },
+      getWaitingCount: async () => {
+        return this.jobsCollection().countDocuments({
+          name,
+          $or: [{ lockedAt: null }, { lockedAt: { $exists: false } }],
+          nextRunAt: { $lte: /* @__PURE__ */ new Date() }
+        });
+      },
+      close: async () => {
+      }
+    };
+  }
+  /** Direct access to the Mongo collection Agenda persists jobs into. */
+  jobsCollection() {
+    return this.db.collection(this.collectionName());
+  }
+  collectionName() {
+    return "_mailerJobs";
+  }
+  async findPending(name, jobId) {
+    return this.jobsCollection().findOne({
+      name,
+      "data.__jobId": jobId,
+      $or: [{ lastFinishedAt: null }, { lastFinishedAt: { $exists: false } }]
+    });
+  }
+  async scheduleRepeatingTick(intervalSeconds) {
+    if (!this.started) {
+      this.agenda.define(QUEUE_NAMES2.tick, async () => {
+      }, { concurrency: 1 });
+      await this.agenda.start();
+      this.started = true;
+    }
+    await this.agenda.every(`${intervalSeconds} seconds`, QUEUE_NAMES2.tick);
+  }
+  async startWorkers(opts) {
+    const exp = this.agendaMod.backoffStrategies.exponential;
+    if (opts.sendRateLimit) {
+      try {
+        const Bottleneck = (await import('bottleneck')).default;
+        this.sendLimiter = new Bottleneck({
+          minTime: Math.ceil(opts.sendRateLimit.durationMs / opts.sendRateLimit.max),
+          maxConcurrent: opts.concurrency.send
+        });
+      } catch {
+        throw new Error(
+          "mailery: queue driver 'agenda' with sendRateLimit requires the 'bottleneck' peer dependency. Run `npm install bottleneck`."
+        );
+      }
+    }
+    const retryBackoff = exp({ delay: 6e4, maxRetries: Math.max(0, opts.retryAttempts - 1), factor: 2 });
+    this.agenda.define(QUEUE_NAMES2.tick, async (job) => {
+      await opts.handlers.tick(job.attrs.data);
+    }, { concurrency: 1 });
+    this.agenda.define(QUEUE_NAMES2.advance, async (job) => {
+      await opts.handlers.advance(job.attrs.data);
+    }, { concurrency: 10, backoff: retryBackoff });
+    this.agenda.define(QUEUE_NAMES2.send, async (job) => {
+      const data = job.attrs.data;
+      if (this.sendLimiter) {
+        await this.sendLimiter.schedule(() => opts.handlers.send(data));
+      } else {
+        await opts.handlers.send(data);
+      }
+    }, { concurrency: opts.concurrency.send, backoff: retryBackoff });
+    this.agenda.define(QUEUE_NAMES2.webhook, async (job) => {
+      await opts.handlers.webhook(job.attrs.data);
+    }, { concurrency: 4, backoff: retryBackoff });
+    if (!this.started) {
+      await this.agenda.start();
+      this.started = true;
+    }
+  }
+  async stopWorkers() {
+    if (!this.started) return;
+    await this.agenda.stop();
+    this.started = false;
+    if (this.sendLimiter) {
+      await this.sendLimiter.stop({ dropWaitingJobs: true }).catch(() => {
+      });
+      this.sendLimiter = null;
+    }
+  }
+  async close() {
+    await this.stopWorkers();
+  }
+};
+
+// src/server/queues/noop.ts
+function noopQueueAPI() {
   return {
-    queues: {
-      tick: adaptBullQueue(bullQueues.tick),
-      advance: adaptBullQueue(bullQueues.advance),
-      send: adaptBullQueue(bullQueues.send),
-      webhook: adaptBullQueue(bullQueues.webhook)
-    },
-    bullQueues
+    add: async () => void 0,
+    getWaitingCount: async () => 0,
+    close: async () => void 0
   };
 }
-async function scheduleTick(bullQueues, intervalSeconds) {
-  await bullQueues.tick.upsertJobScheduler(
-    "mailer-tick-repeat",
-    { every: intervalSeconds * 1e3 },
-    { name: "tick", data: {} }
-  );
-}
-function createWorkers(input) {
-  const names = namespacedQueueNames();
-  const base = { connection: input.redis };
-  const tick = new bullmq.Worker(names.tick, async (job) => input.handlers.tick(job.data), {
-    ...base,
-    concurrency: 1
-    // single tick driver per worker process
-  });
-  const advance = new bullmq.Worker(
-    names.advance,
-    async (job) => input.handlers.advance(job.data),
-    { ...base, concurrency: 10 }
-  );
-  const sendOpts = {
-    ...base,
-    concurrency: input.concurrency.send,
-    limiter: input.sendRateLimit ? { max: input.sendRateLimit.max, duration: input.sendRateLimit.durationMs } : void 0
+var NoopDriver = class {
+  queues = {
+    tick: noopQueueAPI(),
+    advance: noopQueueAPI(),
+    send: noopQueueAPI(),
+    webhook: noopQueueAPI()
   };
-  const send = new bullmq.Worker(names.send, async (job) => input.handlers.send(job.data), sendOpts);
-  const webhook = new bullmq.Worker(
-    names.webhook,
-    async (job) => input.handlers.webhook(job.data),
-    { ...base, concurrency: 4 }
-  );
-  return { tick, advance, send, webhook };
-}
-async function closeQueues(queues) {
-  await Promise.all([queues.tick.close(), queues.advance.close(), queues.send.close(), queues.webhook.close()]);
-}
-async function closeBullQueues(b) {
-  await Promise.all([b.tick.close(), b.advance.close(), b.send.close(), b.webhook.close()]);
-}
-async function closeWorkers(workers) {
-  await Promise.all([workers.tick.close(), workers.advance.close(), workers.send.close(), workers.webhook.close()]);
+  async scheduleRepeatingTick(_intervalSeconds) {
+  }
+  async startWorkers(_opts) {
+  }
+  async stopWorkers() {
+  }
+  async close() {
+  }
+};
+
+// src/server/queues/index.ts
+async function createQueueDriver(config, fallbackDb) {
+  switch (config.driver) {
+    case "bull":
+      return BullDriver.create(config.redis);
+    case "agenda":
+      return AgendaDriver.create({
+        db: config.db ?? fallbackDb,
+        processEverySeconds: config.processEverySeconds,
+        lockLifetimeSeconds: config.lockLifetimeSeconds,
+        collectionName: config.collectionName
+      });
+    case "noop":
+      return new NoopDriver();
+    default: {
+      throw new Error(`mailery: unknown queue driver`);
+    }
+  }
 }
 
 // src/server/runner/triggers.ts
@@ -15075,7 +15279,8 @@ async function dispatchSend(sendId, ctx) {
         status: "sending",
         fromName: rendered.fromName,
         fromEmail: rendered.fromEmail,
-        subject: rendered.subject
+        subject: rendered.subject,
+        updatedAt: /* @__PURE__ */ new Date()
       }
     }
   );
@@ -15149,6 +15354,7 @@ function buildRenderContext(contact, run, vars, ctx) {
   };
 }
 function newSendDoc(input) {
+  const now = /* @__PURE__ */ new Date();
   return {
     _id: input._id,
     dedupeKey: input.dedupeKey,
@@ -15179,7 +15385,8 @@ function newSendDoc(input) {
     clickedLinks: [],
     unsubscribedAt: null,
     complainedAt: null,
-    queuedAt: /* @__PURE__ */ new Date(),
+    queuedAt: now,
+    updatedAt: now,
     sentAt: null,
     deliveredAt: null
   };
@@ -15661,6 +15868,7 @@ async function buildSendDoc(broadcast, template, contact, ctx, scheduledMs, resp
     unsubscribedAt: null,
     complainedAt: null,
     queuedAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date(),
     sentAt: null,
     deliveredAt: null
   };
@@ -15733,13 +15941,36 @@ async function promoteSoftBounces(ctx) {
 }
 
 // src/server/runner/tick.ts
+var STRANDED_SEND_THRESHOLD_MS = 5 * 60 * 1e3;
 async function runTick(ctx) {
+  await ctx.collections.health.updateOne(
+    { _id: "singleton" },
+    {
+      $set: { updatedAt: /* @__PURE__ */ new Date() },
+      $setOnInsert: {
+        _id: "singleton",
+        windowStartedAt: /* @__PURE__ */ new Date(),
+        windowDurationMs: ctx.config.circuitBreaker.windowMinutes * 60 * 1e3,
+        status: "healthy",
+        trippedAt: null,
+        trippedReason: null,
+        manuallyResumedAt: null,
+        counters: { sent: 0, delivered: 0, bounced: 0, hardBounced: 0, softBounced: 0, complained: 0, failedToSend: 0 },
+        rates: { bounceRate: 0, hardBounceRate: 0, complaintRate: 0, failureRate: 0 }
+      }
+    },
+    { upsert: true }
+  ).catch(() => {
+  });
   await processNewlyFiredEventTriggers(ctx).catch((err) => {
     console.error("mailery: triggers scan failed", err);
   });
   await sweepStrandedFlowRuns(ctx).catch((err) => {
     console.error("mailery: sweep failed", err);
   });
+  await sweepStrandedSends(ctx).catch((err) => {
+    console.error("mailery: stranded-send sweep failed", err);
+  });
   await drainOutbox(ctx).catch((err) => {
     console.error("mailery: outbox drain failed", err);
   });
@@ -15753,6 +15984,24 @@ async function runTick(ctx) {
     console.error("mailery: soft-bounce promotion failed", err);
   });
 }
+async function sweepStrandedSends(ctx) {
+  const cutoff = new Date(Date.now() - STRANDED_SEND_THRESHOLD_MS);
+  const cursor = ctx.collections.sends.find(
+    { status: "sending", updatedAt: { $lt: cutoff } },
+    { projection: { _id: 1 } }
+  ).limit(500);
+  for await (const row of cursor) {
+    const reset = await ctx.collections.sends.updateOne(
+      { _id: row._id, status: "sending", updatedAt: { $lt: cutoff } },
+      { $set: { status: "queued", updatedAt: /* @__PURE__ */ new Date() } }
+    );
+    if (reset.modifiedCount === 0) continue;
+    await ctx.queues.send.add("send", { sendId: String(row._id) }, {
+      attempts: ctx.config.sendRetryAttempts,
+      backoff: { type: "exponential", delay: 6e4 }
+    });
+  }
+}
 async function drainOutbox(ctx) {
   const batch = await ctx.collections.outbox.find({ status: "pending" }).sort({ enqueuedAt: 1 }).limit(200).toArray();
   for (const row of batch) {
@@ -15923,12 +16172,11 @@ var Mailer = class _Mailer {
   collections;
   adapter;
   providers;
-  redis;
   queues;
   config;
   events;
-  workers = null;
-  bullQueues;
+  queueDriver;
+  workersStarted = false;
   runnerContext;
   constructor(args) {
     this.config = args.config;
@@ -15936,9 +16184,8 @@ var Mailer = class _Mailer {
     this.collections = args.collections;
     this.adapter = args.adapter;
     this.providers = args.providers;
-    this.redis = args.redis;
-    this.queues = args.queues;
-    this.bullQueues = args.bullQueues;
+    this.queueDriver = args.queueDriver;
+    this.queues = args.queueDriver.queues;
     this.events = args.events;
     this.runnerContext = {
       db: this.db,
@@ -16003,10 +16250,12 @@ var Mailer = class _Mailer {
       throw new Error("Mailer.fromEnv: no provider configured (set MAILER_SENDGRID_API_KEY, ...)");
     }
     const defaultProvider = env.MAILER_DEFAULT_PROVIDER ?? Object.keys(providers)[0];
+    const driverEnv = env.MAILER_QUEUE_DRIVER ?? "bull";
+    const queue = driverEnv === "agenda" ? { driver: "agenda" } : driverEnv === "noop" ? { driver: "noop" } : { driver: "bull", redis: { url: required("MAILER_REDIS_URL") } };
     return _Mailer.init({
       db,
       adapter,
-      redis: { url: required("MAILER_REDIS_URL") },
+      queue,
       providers,
       defaultProvider,
       publicUrl: required("MAILER_PUBLIC_URL"),
@@ -16022,19 +16271,9 @@ var Mailer = class _Mailer {
     }
     const collections = getCollections(config.db, config.collectionPrefix);
     await ensureIndexes(config.db, config.collectionPrefix);
-    let redis = null;
-    let queues;
-    let bullQueues = null;
-    if (config.redis === null) {
-      queues = noopQueues();
-    } else {
-      redis = makeRedis(config.redis);
-      const created = createQueues(redis);
-      queues = created.queues;
-      bullQueues = created.bullQueues;
-      if (!config.workerless) {
-        await scheduleTick(bullQueues, config.tickIntervalSeconds);
-      }
+    const queueDriver = await createQueueDriver(config.queue, config.db);
+    if (!config.workerless && config.queue.driver !== "noop") {
+      await queueDriver.scheduleRepeatingTick(config.tickIntervalSeconds);
     }
     return new _Mailer({
       config,
@@ -16042,9 +16281,7 @@ var Mailer = class _Mailer {
       collections,
       adapter: config.adapter,
       providers: config.providers,
-      redis,
-      queues,
-      bullQueues,
+      queueDriver,
       events: new EventRegistry()
     });
   }
@@ -16352,6 +16589,7 @@ var Mailer = class _Mailer {
       unsubscribedAt: null,
       complainedAt: null,
       queuedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
       sentAt: null,
       deliveredAt: null
     });
@@ -16383,14 +16621,16 @@ var Mailer = class _Mailer {
   // Workers
   // -------------------------------------------------------------------------
   async startWorkers() {
-    if (this.workers) return;
-    if (!this.redis) throw new Error("startWorkers requires a Redis connection (redis was null in config)");
+    if (this.workersStarted) return;
+    if (this.config.queue.driver === "noop") {
+      throw new Error("startWorkers requires a non-noop queue driver");
+    }
     const provider = this.providers[this.config.defaultProvider];
     const sendRate = provider?.sendRatePerSecond ?? this.config.sendRatePerSecond;
-    this.workers = createWorkers({
-      redis: this.redis,
+    await this.queueDriver.startWorkers({
       concurrency: { send: this.config.sendConcurrency },
       sendRateLimit: { max: sendRate, durationMs: 1e3 },
+      retryAttempts: this.config.sendRetryAttempts,
       handlers: {
         tick: async () => {
           await runTick(this.runnerContext);
@@ -16408,6 +16648,7 @@ var Mailer = class _Mailer {
         }
       }
     });
+    this.workersStarted = true;
   }
   /** Process unprocessed webhook events in mailer_webhook_events. */
   async processWebhookBacklog() {
@@ -16434,20 +16675,8 @@ var Mailer = class _Mailer {
     }
   }
   async stop() {
-    if (this.workers) {
-      await closeWorkers(this.workers);
-      this.workers = null;
-    }
-    if (this.bullQueues) {
-      await closeBullQueues(this.bullQueues);
-      this.bullQueues = null;
-    } else {
-      await closeQueues(this.queues);
-    }
-    if (this.redis) {
-      await this.redis.quit().catch(() => {
-      });
-    }
+    await this.queueDriver.close();
+    this.workersStarted = false;
   }
   /** Used internally by the admin router and tests; not part of the public API. */
   getRunnerContext() {
@@ -16543,7 +16772,7 @@ async function createTestMailer(opts = {}) {
   const mailer = await Mailer.init({
     db,
     adapter,
-    redis: null,
+    queue: { driver: "noop" },
     providers: { null: provider },
     defaultProvider: "null",
     publicUrl: "http://localhost:3000",