mail-time 1.4.0 → 4.0.0

package/index.js

@@ -1,633 +1,704 @@
-import JoSk from 'josk';
-import merge from 'deepmerge';
+import { JoSk, RedisAdapter, MongoAdapter, PostgresAdapter } from 'josk';
+import { randomUUID } from 'node:crypto';
 
-const noop = () =>  {};
-const _debug = (isDebug, ...args) => {
-  if (isDebug) {
-    console.info.call(console, '[DEBUG] [mail-time]', `${new Date}`, ...args);
+import { MongoQueue } from './adapters/mongo.js';
+import { RedisQueue } from './adapters/redis.js';
+import { PostgresQueue } from './adapters/postgres.js';
+import { mailTimePreset, presets, presetNames } from './presets.js';
+import { debug, logError, deepMerge, equals, isPlainObject, extractEmail, toAddressList, filterAddressField } from './helpers.js';
+
+const noop = () => {};
+const queueMethods = ['ping', 'iterate', 'getPendingTo', 'push', 'remove', 'update', 'cancel'];
+
+const __withLease = (task, updateObj) => {
+  if (task?.isSending === true && typeof task.tries === 'number' && typeof task.sendingAt === 'number') {
+    return { ...updateObj, leaseTries: task.tries, leaseSendingAt: task.sendingAt };
   }
-};
-const _logError = (...args) => {
-  console.error.call(console, '[ERROR] [mail-time]', `${new Date}`, ...args);
+  return updateObj;
 };
 
-const mongoErrorHandler = (error) => {
-  if (error) {
-    _logError('[mongoErrorHandler]:', error);
-    console.trace();
+const __leaseRemoveOpts = (task) => {
+  if (task?.isSending === true && typeof task.tries === 'number' && typeof task.sendingAt === 'number') {
+    return { leaseTries: task.tries, leaseSendingAt: task.sendingAt };
   }
+  return void 0;
 };
 
-/**
- * Ensure (create) index on MongoDB collection, catch and log exception if thrown
- * @function ensureIndex
- * @param {Collection} collection - Mongo's driver Collection instance
- * @param {object} keys - Field and value pairs where the field is the index key and the value describes the type of index for that field
- * @param {object} opts - Set of options that controls the creation of the index
- * @returns {void 0}
- */
-const ensureIndex = async (collection, keys, opts) => {
-  try {
-    await collection.createIndex(keys, opts);
-  } catch (e) {
-    if (e.code === 85) {
-      let indexName;
-      const indexes = await collection.indexes();
-      for (const index of indexes) {
-        let drop = true;
-        for (const indexKey of Object.keys(keys)) {
-          if (typeof index.key[indexKey] === 'undefined') {
-            drop = false;
-            break;
+const createPool = (concurrency) => {
+  const limit = Math.max(1, concurrency | 0);
+  const queue = [];
+  let active = 0;
+  let drainResolvers = [];
+
+  const tryStart = () => {
+    while (active < limit && queue.length > 0) {
+      const job = queue.shift();
+      active++;
+      job.resolveSlot();
+      Promise.resolve()
+        .then(job.fn)
+        .catch((poolError) => {
+          logError('[pool] unhandled send error', poolError);
+        })
+        .finally(() => {
+          active--;
+          if (active === 0 && queue.length === 0 && drainResolvers.length > 0) {
+            const resolvers = drainResolvers;
+            drainResolvers = [];
+            for (const r of resolvers) r();
           }
-        }
+          tryStart();
+        });
+    }
+  };
+
+  return {
+    /**
+     * Queue `fn` for execution under the concurrency limit.
+     * The returned Promise resolves as soon as a slot is acquired and `fn` has started.
+     * It does NOT wait for `fn` to finish. Use `drain()` to wait for all running jobs to settle.
+     * @param {() => Promise<void>} fn
+     * @returns {Promise<void>}
+     */
+    dispatch(fn) {
+      return new Promise((resolveSlot) => {
+        queue.push({ fn, resolveSlot });
+        tryStart();
+      });
+    },
+    drain() {
+      if (active === 0 && queue.length === 0) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => drainResolvers.push(resolve));
+    },
+    get size() {
+      return active + queue.length;
+    },
+  };
+};
 
-        for (const indexKey of Object.keys(index.key)) {
-          if (typeof keys[indexKey] === 'undefined') {
-            drop = false;
-            break;
-          }
-        }
+const mailOptionRecipients = (mailOption) => {
+  if (!mailOption) {
+    return [];
+  }
+  return [
+    ...toAddressList(mailOption.to),
+    ...toAddressList(mailOption.cc),
+    ...toAddressList(mailOption.bcc),
+  ];
+};
 
-        if (drop) {
-          indexName = index.name;
-          break;
+const collectAcceptedSet = (task) => {
+  const set = new Set();
+  for (const mo of (task?.mailOptions || [])) {
+    if (Array.isArray(mo.accepted)) {
+      for (const addr of mo.accepted) {
+        if (typeof addr === 'string') {
+          set.add(addr.toLowerCase());
         }
       }
+    }
+  }
+  return set;
+};
 
-      if (indexName) {
-        await collection.dropIndex(indexName);
-        await collection.createIndex(keys, opts);
-      }
-    } else {
-      _logError(`[ensureIndex] Can not set ${Object.keys(keys).join(' + ')} index on "${collection._name}" collection`, { keys, opts, details: e });
+const collectAllRecipients = (task) => {
+  const set = new Set();
+  for (const mo of (task?.mailOptions || [])) {
+    for (const addr of mailOptionRecipients(mo)) {
+      set.add(addr);
+    }
+  }
+  return set;
+};
+
+const buildRejectionErrorMap = (info) => {
+  const map = new Map();
+  const rejected = Array.isArray(info?.rejected) ? info.rejected : [];
+  const rejectedErrors = Array.isArray(info?.rejectedErrors) ? info.rejectedErrors : [];
+  for (let i = 0; i < rejected.length; i++) {
+    const addr = extractEmail(rejected[i]);
+    if (!addr) {
+      continue;
     }
+    const err = rejectedErrors[i];
+    map.set(addr, err ? `${err.message || err}` : 'Recipient rejected by transport');
   }
+  return map;
 };
 
+let DEFAULT_TEMPLATE = '<!DOCTYPE html><html xmlns=http://www.w3.org/1999/xhtml><meta content="text/html; charset=utf-8"http-equiv=Content-Type><meta content="width=device-width,initial-scale=1"name=viewport><title>{{subject}}</title><style>body{-webkit-font-smoothing:antialiased;-webkit-text-size-adjust:none;font-family:Tiempos,Georgia,Times,serif;font-weight:400;width:100%;height:100%;background:#fff;font-size:15px;color:#000;line-height:1.5}a{text-decoration:underline;border:0;color:#000;outline:0;color:inherit}a:hover{text-decoration:none}a[href^=sms],a[href^=tel]{text-decoration:none;color:#000;cursor:default}a img{border:none;text-decoration:none}td{font-family:Tiempos,Georgia,Times,serif;font-weight:400}hr{height:1px;border:none;width:100%;margin:0;margin-top:25px;margin-bottom:25px;background-color:#ECECEC}h1,h2,h3,h4,h5,h6{font-family:HelveticaNeue,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:300;line-height:normal;margin-top:35px;margin-bottom:4px;margin-left:0;margin-right:0}h1{margin:23px 15px;font-size:25px}h2{margin-top:15px;font-size:21px}h3{font-weight:400;font-size:19px;border-bottom:1px solid #ECECEC}h4{font-weight:400;font-size:18px}h5{font-weight:400;font-size:17px}h6{font-weight:600;font-size:16px}h1 a,h2 a,h3 a,h4 a,h5 a,h6 a{text-decoration:none}pre{font-family:Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,sans-serif;display:block;font-size:13px;padding:9.5px;margin:0 0 10px;line-height:1.42;color:#333;word-break:break-all;word-wrap:break-word;background-color:#f5f5f5;border:1px solid #ccc;border-radius:4px;text-align:left!important;max-width:100%;white-space:pre-wrap;width:auto;overflow:auto}code{font-size:13px;font-family:font-family: Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,sans-serif;border:1px solid rgba(0,0,0,.223);border-radius:2px;padding:1px 2px;word-break:break-all;word-wrap:break-word}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border:none;border-radius:0;word-break:break-all;word-wrap:break-word}td{text-align:center}table{border-collapse:collapse!important}.force-full-width{width:100%!important}</style><style media=screen>@media screen{h1,h2,h3,h4,h5,h6{font-family:\'Helvetica Neue\',Arial,sans-serif!important}td{font-family:Tiempos,Georgia,Times,serif!important}code,pre{font-family:Consolas,Menlo,Monaco,\'Lucida Console\',\'Liberation Mono\',\'DejaVu Sans Mono\',\'Bitstream Vera Sans Mono\',\'Courier New\',monospace,sans-serif!important}}</style><style media="only screen and (max-width:480px)">@media only screen and (max-width:480px){table[class=w320]{width:100%!important}}</style><body bgcolor=#FFFFFF class=body style=padding:0;margin:0;display:block;background:#fff;-webkit-text-size-adjust:none><table cellpadding=0 cellspacing=0 width=100% align=center><tr><td align=center valign=top bgcolor=#FFFFFF width=100%><center><table cellpadding=0 cellspacing=0 width=600 style="margin:0 auto"class=w320><tr><td align=center valign=top><table cellpadding=0 cellspacing=0 width=100% style="margin:0 auto;border-bottom:1px solid #ddd"bgcolor=#ECECEC><tr><td><h1>{{{subject}}}</h1></table><table cellpadding=0 cellspacing=0 width=100% style="margin:0 auto"bgcolor=#F2F2F2><tr><td><center><table cellpadding=0 cellspacing=0 width=100% style="margin:0 auto"><tr><td align=left style="text-align:left;padding:30px 25px">{{{html}}}</table></center></table></table></center></table>';
+
 /**
- * Check if entities of various types are equal
- * including edge cases like unordered Objects and Array
- * @function equals
- * @param {mix} a
- * @param {mix} b
- * @returns {boolean}
+ * @typedef {import('./presets.js').MailTimePresetName} MailTimePresetName
  */
-const equals = (a, b) => {
-  let i;
-  if (a === b) {
-    return true;
-  }
 
-  if (!a || !b) {
-    return false;
-  }
+/**
+ * @typedef {import('./presets.js').MailTimePresetConfig} MailTimePresetConfig
+ */
 
-  if (!(typeof a === 'object' && typeof b === 'object')) {
-    return false;
-  }
+/**
+ * @typedef {{ status: string, code: number, statusCode: number, error?: unknown }} MailTimePingResult
+ */
 
-  if (a instanceof Date && b instanceof Date) {
-    return a.valueOf() === b.valueOf();
-  }
+/**
+ * @typedef {{ [key: string]: any, query?: (queryText: string, values?: unknown[]) => Promise<{ rows?: unknown[], rowCount?: number | null }> }} MailTimeStorageClient
+ */
 
-  if (a instanceof Array) {
-    if (!(b instanceof Array)) {
-      return false;
-    }
+/**
+ * @typedef {{ [key: string]: any }} MailTimeMongoDb
+ */
 
-    if (a.length !== b.length) {
-      return false;
-    }
+/**
+ * @typedef {{ [key: string]: any }} MailTimeTransport
+ */
 
-    const _a = a.slice();
-    const _b = b.slice();
-    let j;
-    for (i = _a.length - 1; i >= 0; i--) {
-      let result = false;
-      for (j = _b.length - 1; j >= 0; j--) {
-        if (equals(_a[i], _b[j])) {
-          result = true;
-          _a.splice(i, 1);
-          _b.splice(j, 1);
-          break;
-        }
-      }
+/**
+ * @typedef {{ [key: string]: any, type?: 'mongo' | 'redis' | 'postgres', client?: MailTimeStorageClient, db?: MailTimeMongoDb, prefix?: string, resetOnInit?: boolean, useHashTags?: boolean }} MailTimeJoSkAdapterOptions
+ */
 
-      if (!result) {
-        return false;
-      }
-    }
-    return true;
-  }
+/**
+ * @typedef {{ [key: string]: any, adapter: MailTimeJoSkAdapterOptions | object, debug?: boolean, autoClear?: boolean, zombieTime?: number, minRevolvingDelay?: number, maxRevolvingDelay?: number, execute?: 'batch' | 'one', concurrency?: number, lockOwnerId?: string, resetOnInit?: boolean, onError?: (title: string, details: object) => void, onExecuted?: (uid: string, details: object) => void }} MailTimeJoSkOptions
+ */
 
-  i = 0;
-  if (typeof a === 'object' && typeof b === 'object') {
-    const akeys = Object.keys(a);
-    const bkeys = Object.keys(b);
+/**
+ * @typedef {{ uuid: string, to?: string | string[], tries: number, sendAt: number, isSent: boolean, isCancelled: boolean, isFailed: boolean, isSending?: boolean, sendingAt?: number, template?: string | false, transport: number, concatSubject?: string | false, mailOptions: MailTimeMailOptions[] }} MailTimeTask
+ */
 
-    if (akeys.length !== bkeys.length) {
-      return false;
-    }
+/**
+ * @typedef {{ limit?: number, sendingTimeout?: number }} MailTimeIterateOptions
+ */
 
-    for (i = akeys.length - 1; i >= 0; i--) {
-      if (!hasOwnProperty.call(b, akeys[i])) {
-        return  false;
-      }
+/**
+ * @typedef {{ ping: () => Promise<MailTimePingResult>, iterate: (opts?: MailTimeIterateOptions) => Promise<void> | void, getPendingTo: (to: string, sendAt: number) => Promise<MailTimeTask | object | null>, push: (email: MailTimeTask) => Promise<void> | void, cancel: (uuid: string) => Promise<boolean>, remove: (email: MailTimeTask | object, opts?: { leaseTries: number, leaseSendingAt: number }) => Promise<boolean>, update: (email: MailTimeTask | object, updateObj: object) => Promise<boolean>, ready?: () => Promise<void> }} CustomQueue
+ */
 
-      if (!equals(a[akeys[i]], b[akeys[i]])) {
-        return false;
-      }
-    }
+/**
+ * @typedef {{ address: string, error: string }} MailTimeRejectedRecipient
+ */
 
-    return true;
-  }
-  return false;
-};
+/**
+ * @typedef {{ [key: string]: any, to: string | string[], sendAt?: Date | number, template?: string, concatSubject?: string, text?: string | false, html?: string | false, subject?: string, accepted?: string[], rejected?: MailTimeRejectedRecipient[] }} MailTimeMailOptions
+ */
 
-let DEFAULT_TEMPLATE = '<!DOCTYPE html><html xmlns=http://www.w3.org/1999/xhtml><meta content="text/html; charset=utf-8"http-equiv=Content-Type><meta content="width=device-width,initial-scale=1"name=viewport><title>{{subject}}</title><style>body{-webkit-font-smoothing:antialiased;-webkit-text-size-adjust:none;font-family:Tiempos,Georgia,Times,serif;font-weight:400;width:100%;height:100%;background:#fff;font-size:15px;color:#000;line-height:1.5}a{text-decoration:underline;border:0;color:#000;outline:0;color:inherit}a:hover{text-decoration:none}a[href^=sms],a[href^=tel]{text-decoration:none;color:#000;cursor:default}a img{border:none;text-decoration:none}td{font-family:Tiempos,Georgia,Times,serif;font-weight:400}hr{height:1px;border:none;width:100%;margin:0;margin-top:25px;margin-bottom:25px;background-color:#ECECEC}h1,h2,h3,h4,h5,h6{font-family:HelveticaNeue,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:300;line-height:normal;margin-top:35px;margin-bottom:4px;margin-left:0;margin-right:0}h1{margin:23px 15px;font-size:25px}h2{margin-top:15px;font-size:21px}h3{font-weight:400;font-size:19px;border-bottom:1px solid #ECECEC}h4{font-weight:400;font-size:18px}h5{font-weight:400;font-size:17px}h6{font-weight:600;font-size:16px}h1 a,h2 a,h3 a,h4 a,h5 a,h6 a{text-decoration:none}pre{font-family:Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,sans-serif;display:block;font-size:13px;padding:9.5px;margin:0 0 10px;line-height:1.42;color:#333;word-break:break-all;word-wrap:break-word;background-color:#f5f5f5;border:1px solid #ccc;border-radius:4px;text-align:left!important;max-width:100%;white-space:pre-wrap;width:auto;overflow:auto}code{font-size:13px;font-family:font-family: Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,sans-serif;border:1px solid rgba(0,0,0,.223);border-radius:2px;padding:1px 2px;word-break:break-all;word-wrap:break-word}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border:none;border-radius:0;word-break:break-all;word-wrap:break-word}td{text-align:center}table{border-collapse:collapse!important}.force-full-width{width:100%!important}</style><style media=screen>@media screen{h1,h2,h3,h4,h5,h6{font-family:\'Helvetica Neue\',Arial,sans-serif!important}td{font-family:Tiempos,Georgia,Times,serif!important}code,pre{font-family:Consolas,Menlo,Monaco,\'Lucida Console\',\'Liberation Mono\',\'DejaVu Sans Mono\',\'Bitstream Vera Sans Mono\',\'Courier New\',monospace,sans-serif!important}}</style><style media="only screen and (max-width:480px)">@media only screen and (max-width:480px){table[class=w320]{width:100%!important}}</style><body bgcolor=#FFFFFF class=body style=padding:0;margin:0;display:block;background:#fff;-webkit-text-size-adjust:none><table cellpadding=0 cellspacing=0 width=100% align=center><tr><td align=center valign=top bgcolor=#FFFFFF width=100%><center><table cellpadding=0 cellspacing=0 width=600 style="margin:0 auto"class=w320><tr><td align=center valign=top><table cellpadding=0 cellspacing=0 width=100% style="margin:0 auto;border-bottom:1px solid #ddd"bgcolor=#ECECEC><tr><td><h1>{{{subject}}}</h1></table><table cellpadding=0 cellspacing=0 width=100% style="margin:0 auto"bgcolor=#F2F2F2><tr><td><center><table cellpadding=0 cellspacing=0 width=100% style="margin:0 auto"><tr><td align=left style="text-align:left;padding:30px 25px">{{{html}}}</table></center></table></table></center></table>';
+/**
+ * @typedef {{ subject?: string }} MailTimeConcatEmailsOptions
+ */
+
+/**
+ * @typedef {{ queue: RedisQueue | MongoQueue | PostgresQueue | CustomQueue, type?: 'server' | 'client', from?: string | ((transport: MailTimeTransport) => string), transports?: MailTimeTransport[], strategy?: 'backup' | 'balancer', failsToNext?: number, retries?: number, maxTries?: number, retryDelay?: number, interval?: number, keepHistory?: boolean, concatEmails?: boolean | MailTimeConcatEmailsOptions, concatSubject?: string, concatDelimiter?: string, concatDelay?: number, concatThrottling?: number, revolvingInterval?: number, mode?: 'one' | 'batch', concurrency?: number, sendingTimeout?: number, verifyTransports?: boolean, template?: string, prefix?: string, debug?: boolean, josk?: MailTimeJoSkOptions, onError?: (error: unknown, email: MailTimeTask | null, details?: object) => void, onSent?: (email: MailTimeTask, details?: object) => void }} MailTimeOptions
+ */
 
 /** Class of MailTime */
-export default class MailTime {
+class MailTime {
+  /**
+   * Create a MailTime instance
+   * @param {MailTimeOptions} opts - configuration object
+   */
   constructor (opts) {
-    if (!opts || typeof opts !== 'object' || opts === null) {
+    if (!opts || typeof opts !== 'object') {
       throw new TypeError('[mail-time] Configuration object must be passed into MailTime constructor');
     }
 
-    if (!opts.db) {
-      throw new Error('[mail-time] MongoDB database {db} option is required, like returned from `MongoClient.connect`');
+    if (!opts.queue || typeof opts.queue !== 'object') {
+      throw new Error('[mail-time] {queue} option is required: provide a MongoQueue, RedisQueue, PostgresQueue, or CustomQueue instance');
     }
 
-    this.callbacks = {};
-    this.type = (!opts.type || (opts.type !== 'client' && opts.type !== 'server')) ? 'server' : opts.type;
-    this.debug = (opts.debug !== true) ? false : true;
-    this.prefix = opts.prefix || '';
-    this.maxTries = ((opts.maxTries && !isNaN(opts.maxTries)) ? parseInt(opts.maxTries) : 59) + 1;
-    this.interval = ((opts.interval && !isNaN(opts.interval)) ? parseInt(opts.interval) : 60) * 1000;
-    this.template = (typeof opts.template === 'string') ? opts.template : '{{{html}}}';
-    this.zombieTime = opts.zombieTime || 32786;
-    this.keepHistory = opts.keepHistory || false;
+    this.queue = opts.queue;
+
+    for (let i = queueMethods.length - 1; i >= 0; i--) {
+      if (typeof this.queue[queueMethods[i]] !== 'function') {
+        throw new Error(`[mail-time] {queue} instance is missing {${queueMethods[i]}} method that is required!`);
+      }
+    }
 
-    this.revolvingInterval = opts.revolvingInterval || 1536;
-    this.minRevolvingDelay = opts.minRevolvingDelay || 512;
-    this.maxRevolvingDelay = opts.maxRevolvingDelay || 2048;
+    this.debug = opts.debug === true;
+    this.__debug = (...args) => {
+      debug(this.debug, `[${this.prefix || 'default'}]`, ...args);
+    };
+
+    this.type = (opts.type === 'client' || opts.type === 'server') ? opts.type : 'server';
+    this.prefix = (typeof opts.prefix === 'string') ? opts.prefix : '';
 
-    if (this.interval < 2048 || isNaN(this.interval)) {
-      this.interval = 3072;
+    if (typeof opts.retries === 'number') {
+      if (opts.retries < 0) {
+        throw new Error('[mail-time] {retries} must be a non-negative number');
+      }
+      this.maxTries = opts.retries + 1;
+    } else if (typeof opts.maxTries === 'number') {
+      this.maxTries = (opts.maxTries < 1) ? 1 : opts.maxTries;
+    } else {
+      this.maxTries = 60;
     }
 
-    if (this.zombieTime < 8192 || isNaN(this.zombieTime)) {
-      this.zombieTime = 8192;
+    if (typeof opts.retryDelay === 'number') {
+      this.retryDelay = opts.retryDelay;
+    } else if (typeof opts.interval === 'number') {
+      this.retryDelay = opts.interval * 1000;
+    } else {
+      this.retryDelay = 60000;
     }
 
-    this.failsToNext = (opts.failsToNext && !isNaN(opts.failsToNext)) ? parseInt(opts.failsToNext) : 4;
+    this.template = (typeof opts.template === 'string') ? opts.template : '{{{html}}}';
+    this.keepHistory = opts.keepHistory === true;
+    this.onSent = (typeof opts.onSent === 'function') ? opts.onSent.bind(this) : noop;
+    this.onError = (typeof opts.onError === 'function') ? opts.onError.bind(this) : noop;
+
+    this.revolvingInterval = (typeof opts.revolvingInterval === 'number' && opts.revolvingInterval > 0) ? opts.revolvingInterval : 1536;
+    this.mode = (opts.mode === 'one' || opts.mode === 'batch') ? opts.mode : 'batch';
+    this.concurrency = (typeof opts.concurrency === 'number' && opts.concurrency > 0 && Number.isFinite(opts.concurrency)) ? Math.floor(opts.concurrency) : 1;
+    this.sendingTimeout = (typeof opts.sendingTimeout === 'number' && opts.sendingTimeout > 0) ? opts.sendingTimeout : 300000;
+    this.__isDestroyed = false;
+    this.__readyPromise = null;
+    this.__schedulerTimer = null;
+    this.__inFlight = new Set();
+    this.__pool = createPool(this.concurrency);
+
+    this.failsToNext = (typeof opts.failsToNext === 'number' && opts.failsToNext > 0) ? opts.failsToNext : 4;
     this.strategy = (opts.strategy === 'backup' || opts.strategy === 'balancer') ? opts.strategy : 'backup';
-    this.transports = opts.transports || [];
+    this.transports = Array.isArray(opts.transports) ? opts.transports : [];
     this.transport = 0;
-    this.from = (() => {
-      if (typeof opts.from === 'string') {
-        return () => {
-          return opts.from;
-        };
-      }
+    this.verifyTransports = opts.verifyTransports !== false;
+    this.__unhealthyTransports = new Set();
+
+    if (typeof opts.from === 'string') {
+      const fromStr = opts.from;
+      this.from = () => fromStr;
+    } else if (typeof opts.from === 'function') {
+      this.from = opts.from;
+    } else {
+      this.from = false;
+    }
+
+    this.queue.mailTimeInstance = this;
 
-      if (typeof opts.from === 'function') {
-        return opts.from;
+    /** @type {string} */
+    this.concatSubject = (typeof opts.concatSubject === 'string' && opts.concatSubject) ? opts.concatSubject : 'Multiple notifications';
+    if (opts.concatEmails === true) {
+      this.concatEmails = true;
+    } else if (isPlainObject(opts.concatEmails)) {
+      this.concatEmails = true;
+      if (typeof opts.concatEmails.subject === 'string' && opts.concatEmails.subject) {
+        this.concatSubject = opts.concatEmails.subject;
       }
+    } else {
+      this.concatEmails = false;
+    }
+    this.concatDelimiter = (typeof opts.concatDelimiter === 'string' && opts.concatDelimiter) ? opts.concatDelimiter : '<hr>';
 
-      return false;
-    })();
-
-    this.concatEmails = (opts.concatEmails !== true) ? false : true;
-    this.concatSubject = (opts.concatSubject && typeof opts.concatSubject === 'string') ? opts.concatSubject : 'Multiple notifications';
-    this.concatDelimiter = (opts.concatDelimiter && typeof opts.concatDelimiter === 'string') ? opts.concatDelimiter : '<hr>';
-    this.concatThrottling = ((opts.concatThrottling && !isNaN(opts.concatThrottling)) ? parseInt(opts.concatThrottling) : 60) * 1000;
-
-    if (this.concatThrottling < 2048) {
-      this.concatThrottling = 3072;
-    }
-
-    _debug(this.debug, 'DEBUG ON {debug: true}');
-    _debug(this.debug, `INITIALIZING [type: ${this.type}]`);
-    _debug(this.debug, `INITIALIZING [strategy: ${this.strategy}]`);
-    _debug(this.debug, `INITIALIZING [prefix: ${this.prefix}]`);
-    _debug(this.debug, `INITIALIZING [maxTries: ${this.maxTries}]`);
-    _debug(this.debug, `INITIALIZING [failsToNext: ${this.failsToNext}]`);
-
-    if (opts.type === 'server' && (this.transports.constructor !== Array || !this.transports.length)) {
-      throw new Error('[mail-time] transports is required and must be an Array, like returned from `nodemailer.createTransport`');
-    }
-
-    this.collection = opts.db.collection(`__mailTimeQueue__${this.prefix}`);
-    ensureIndex(this.collection, { isSent: 1, to: 1, sendAt: 1 });
-    ensureIndex(this.collection, { isSent: 1, sendAt: 1, tries: 1 }, { background: true });
-
-    // MongoDB Collection Schema:
-    // _id
-    // to          {String|[String]}
-    // tries       {Number}  - qty of send attempts
-    // sendAt      {Date}    - When letter should be sent
-    // isSent      {Boolean} - Email status
-    // template    {String}  - Template for this email
-    // transport   {Number}  - Last used transport
-    // concatSubject {String|Boolean} - Email concatenation subject
-    // ---
-    // mailOptions         {[Object]}  - Array of nodeMailer's `mailOptions`
-    // mailOptions.to      {String|Array} - [REQUIRED]
-    // mailOptions.from    {String}
-    // mailOptions.text    {String|Boolean}
-    // mailOptions.html    (String)
-    // mailOptions.subject {String}
-    // mailOptions.Other nodeMailer `sendMail` options...
+    if (typeof opts.concatDelay === 'number') {
+      this.concatDelay = opts.concatDelay;
+    } else if (typeof opts.concatThrottling === 'number') {
+      this.concatDelay = opts.concatThrottling * 1000;
+    } else {
+      this.concatDelay = 60000;
+    }
 
+    this.__debug('DEBUG ON {debug: true}');
+    this.__debug(`INITIALIZING [type: ${this.type}]`);
+    this.__debug(`INITIALIZING [strategy: ${this.strategy}]`);
+    this.__debug(`INITIALIZING [josk.adapter.type: ${opts?.josk?.adapter?.type || 'custom'}]`);
+    this.__debug(`INITIALIZING [prefix: ${this.prefix}]`);
+    this.__debug(`INITIALIZING [retries: ${this.maxTries - 1}]`);
+    this.__debug(`INITIALIZING [failsToNext: ${this.failsToNext}]`);
+    this.__debug(`INITIALIZING [mode: ${this.mode}]`);
+    this.__debug(`INITIALIZING [concurrency: ${this.concurrency}]`);
+    this.__debug(`INITIALIZING [sendingTimeout: ${this.sendingTimeout}]`);
+
+    /** SERVER-SPECIFIC CHECKS AND CONFIG */
     if (this.type === 'server') {
-      const scheduler = new JoSk({
-        db: opts.db,
-        debug: this.debug,
-        prefix: `mailTimeQueue${this.prefix}`,
-        resetOnInit: false,
-        zombieTime: this.zombieTime,
-        minRevolvingDelay: this.minRevolvingDelay,
-        maxRevolvingDelay: this.maxRevolvingDelay
-      });
-
-      scheduler.setInterval(this.___send.bind(this), this.revolvingInterval, `mailTimeQueue${this.prefix}`);
-    }
-  }
+      if (!this.transports.length) {
+        throw new Error('[mail-time] {transports} is required for {type: "server"} and must be a non-empty Array, like one returned from `nodemailer.createTransport`');
+      }
 
-  static get Template() {
-    return DEFAULT_TEMPLATE;
-  }
+      if (!opts.josk || typeof opts.josk !== 'object') {
+        throw new Error('[mail-time] {josk} option is required {object} for {type: "server"}');
+      }
 
-  static set Template(newVal) {
-    DEFAULT_TEMPLATE = newVal;
-  }
+      if (!opts.josk.adapter || typeof opts.josk.adapter !== 'object') {
+        throw new Error('[mail-time] {josk.adapter} option is required {object} *or* custom adapter Class');
+      }
 
-  ___compileMailOpts(transport, task) {
-    let _mailOpts = {};
+      this.josk = { ...opts.josk };
+      const buildAdapterOptions = () => {
+        const adapterOptions = {
+          prefix: `mailTimeQueue${this.prefix}`,
+          ...opts.josk.adapter,
+        };
 
-    if (!transport) {
-      throw new Error('[mail-time] [sendMail] [___compileMailOpts] transport not available or misconfiguration is in place!');
-    }
+        if (typeof opts.josk.resetOnInit === 'boolean' && typeof adapterOptions.resetOnInit !== 'boolean') {
+          adapterOptions.resetOnInit = opts.josk.resetOnInit;
+        }
 
-    if (transport._options && typeof transport._options === 'object' && transport._options !== null && transport._options.mailOptions) {
-      _mailOpts = merge(_mailOpts, transport._options.mailOptions);
-    }
+        return adapterOptions;
+      };
 
-    if (transport.options && typeof transport.options === 'object' && transport.options !== null && transport.options.mailOptions) {
-      _mailOpts = merge(_mailOpts, transport.options.mailOptions);
-    }
+      const adapterType = opts.josk.adapter.type;
+      if (adapterType === 'mongo') {
+        if (!opts.josk.adapter.db) {
+          throw new Error('[mail-time] {josk.adapter.db} option required for {josk.adapter.type: "mongo"}');
+        }
+        this.josk.adapter = new MongoAdapter(buildAdapterOptions());
+      } else if (adapterType === 'redis') {
+        if (!opts.josk.adapter.client) {
+          throw new Error('[mail-time] {josk.adapter.client} option required for {josk.adapter.type: "redis"}');
+        }
+        this.josk.adapter = new RedisAdapter(buildAdapterOptions());
+      } else if (adapterType === 'postgres') {
+        if (!opts.josk.adapter.client) {
+          throw new Error('[mail-time] {josk.adapter.client} option required for {josk.adapter.type: "postgres"}');
+        }
+        this.josk.adapter = new PostgresAdapter(buildAdapterOptions());
+      }
 
-    _mailOpts = merge(_mailOpts, {
-      html: '',
-      text: '',
-      subject: ''
-    });
+      this.josk.minRevolvingDelay = (typeof opts.josk.minRevolvingDelay === 'number') ? opts.josk.minRevolvingDelay : 512;
+      this.josk.maxRevolvingDelay = (typeof opts.josk.maxRevolvingDelay === 'number') ? opts.josk.maxRevolvingDelay : 2048;
+      this.josk.zombieTime = (typeof opts.josk.zombieTime === 'number') ? opts.josk.zombieTime : 60000;
+      this.josk.execute = (opts.josk.execute === 'one' || opts.josk.execute === 'batch') ? opts.josk.execute : 'batch';
+      this.josk.concurrency = (typeof opts.josk.concurrency === 'number' && opts.josk.concurrency > 0) ? opts.josk.concurrency : Infinity;
+      this.josk.autoClear = opts.josk.autoClear === true;
 
-    for (let i = 0; i < task.mailOptions.length; i++) {
-      if (task.mailOptions[i].html) {
-        if (task.mailOptions.length > 1) {
-          _mailOpts.html += this.___render(this.concatDelimiter, task.mailOptions[i]) + this.___render(task.mailOptions[i].html, task.mailOptions[i]);
-        } else {
-          _mailOpts.html = this.___render(task.mailOptions[i].html, task.mailOptions[i]);
-        }
-        delete task.mailOptions[i].html;
+      if (typeof opts.josk.lockOwnerId === 'string' && opts.josk.lockOwnerId.length > 0) {
+        this.josk.lockOwnerId = opts.josk.lockOwnerId;
       }
 
-      if (task.mailOptions[i].text) {
-        if (task.mailOptions.length > 1) {
-          _mailOpts.text += '\r\n' + this.___render(task.mailOptions[i].text, task.mailOptions[i]);
-        } else {
-          _mailOpts.text = this.___render(task.mailOptions[i].text, task.mailOptions[i]);
-        }
-        delete task.mailOptions[i].text;
+      if (typeof opts.josk.onError !== 'function') {
+        this.josk.onError = (title, details) => {
+          logError(`[scheduler] ${title}`, details);
+        };
       }
 
-      _mailOpts = merge(_mailOpts, task.mailOptions[i]);
-    }
+      this.scheduler = new JoSk({
+        debug: this.debug,
+        ...this.josk,
+      });
 
-    if (_mailOpts.html && (task.template || this.template)) {
-      _mailOpts.html = this.___render((task.template || this.template), _mailOpts);
+      this.__schedulerTimer = this.scheduler.setInterval(this.___iterate.bind(this), this.revolvingInterval, `mailTimeQueue${this.prefix}`);
     }
 
-    if (task.mailOptions.length > 1) {
-      _mailOpts.subject = task.concatSubject || this.concatSubject || _mailOpts.subject;
-    }
+    this.__readyPromise = this.___ready();
+    this.__readyPromise.catch(() => void 0);
+  }
 
-    if (!_mailOpts.from && this.from) {
-      _mailOpts.from = this.from(transport);
-    }
+  static get Template() {
+    return DEFAULT_TEMPLATE;
+  }
 
-    return _mailOpts;
+  static set Template(newVal) {
+    DEFAULT_TEMPLATE = newVal;
   }
 
   /**
+   * @async
    * @memberOf MailTime
-   * @name ___send
-   * @param ready {Function} - See JoSk NPM package
-   * @returns {void}
+   * @name ping
+   * @description Check package readiness and connection to Storage
+   * @returns {Promise<MailTimePingResult>}
+   * @throws {Error}
    */
-  ___send(ready) {
-    const cursor = this.collection.find({
-      isSent: false,
-      sendAt: {
-        $lte: new Date()
-      },
-      tries: {
-        $lt: this.maxTries
-      }
-    }, {
-      projection: {
-        _id: 1,
-        tries: 1,
-        template: 1,
-        transport: 1,
-        mailOptions: 1,
-        concatSubject: 1
+  async ping() {
+    this.__debug('[ping]');
+    if (this.scheduler) {
+      const schedulerPing = await this.scheduler.ping();
+      if (schedulerPing.status !== 'OK') {
+        return schedulerPing;
       }
-    });
-
-    cursor.forEach(async (task) => {
-      try {
-        await this.collection.updateOne({
-          _id: task._id
-        }, {
-          $set: {
-            isSent: true
-          },
-          $inc: {
-            tries: 1
-          }
-        });
-
-        let transport;
-        let transportIndex;
-        if (this.strategy === 'balancer') {
-          this.transport = this.transport + 1;
-          if (this.transport >= this.transports.length) {
-            this.transport = 0;
-          }
-          transportIndex = this.transport;
-          transport = this.transports[transportIndex];
-        } else {
-          transportIndex = task.transport;
-          transport = this.transports[transportIndex];
-        }
-
-        const _mailOpts = this.___compileMailOpts(transport, task);
-
-        _debug(this.debug, '[sendMail] [sending] To:', _mailOpts.to);
-        transport.sendMail(_mailOpts, (error, info) => {
-          if (error) {
-            this.___handleError(task, error, info);
-            return;
-          }
+    }
+    return await this.queue.ping();
+  }
 
-          if (info.accepted && !info.accepted.length) {
-            this.___handleError(task, 'Message not accepted or Greeting never received', info);
-            return;
-          }
+  /**
+   * @async
+   * @memberOf MailTime
+   * @name ready
+   * @description Wait until queue and scheduler storage are ready
+   * @returns {Promise<MailTime>}
+   */
+  async ready() {
+    this.__debug('[ready]');
+    return await this.__readyPromise;
+  }
 
-          _debug(this.debug, `email successfully sent, attempts: #${task.tries}, transport #${transportIndex} to: `, _mailOpts.to);
+  /**
+   * @memberOf MailTime
+   * @name destroy
+   * @description Stop the scheduler and block future dispatches. Pass `{ drain: true }` to also wait for in-flight SMTP attempts (returns a Promise).
+   * @param {{ drain?: boolean }} [opts]
+   * @returns {boolean | Promise<boolean>}
+   */
+  destroy(opts) {
+    this.__debug('[destroy]', opts);
+    if (this.__isDestroyed) {
+      return false;
+    }
 
-          if (!this.keepHistory) {
-            this.collection.deleteOne({
-              _id: task._id
-            }).catch(mongoErrorHandler);
-          }
+    this.__isDestroyed = true;
+    if (this.scheduler && typeof this.scheduler.destroy === 'function') {
+      this.scheduler.destroy();
+    }
+    if (opts && opts.drain === true && this.__pool) {
+      return this.__pool.drain().then(() => true);
+    }
+    return true;
+  }
 
-          this.___triggerCallbacks(void 0, task, info);
-          return;
-        });
-      } catch (e) {
-        _logError('Exception during runtime:', e);
-        this.___handleError(task, e, {});
-      }
-    }).catch((forEachError) => {
-      _logError('[___send] [forEach] [forEachError]', forEachError);
-    }).finally(() => {
-      ready();
-      cursor.close();
-    });
+  /**
+   * @async
+   * @memberOf MailTime
+   * @name drain
+   * @description Wait for all in-flight email send attempts to settle
+   * @returns {Promise<void>}
+   */
+  async drain() {
+    this.__debug('[drain]');
+    if (this.__pool) {
+      await this.__pool.drain();
+    }
   }
 
   /**
    * @memberOf MailTime
    * @name send
    * @description alias of `sendMail`
-   * @returns {void}
+   * @param {MailTimeMailOptions} opts - email options
+   * @returns {Promise<string>} uuid of the email
    */
-  send(opts, callback) {
-    this.sendMail(opts, callback);
+  async send(opts) {
+    this.__debug('[send]', opts);
+    return await this.sendMail(opts);
   }
 
   /**
+   * @async
    * @memberOf MailTime
    * @name sendMail
-   * @param opts          {Object}   - Letter options with next properties:
-   * @param opts.sendAt   {Date}     - When email should be sent
-   * @param opts.template {String}   - Template string
-   * @param opts[key]     {mix}      - Other MailOptions according to NodeMailer lib documentation
-   * @param callback      {Function} - [OPTIONAL] Callback function
-   * @returns {void}
+   * @description add email to the queue or append to existing letter if {concatEmails: true}
+   * @param {MailTimeMailOptions} opts - email options
+   * @returns {Promise<string>} uuid of the email
+   * @throws {Error}
    */
-  sendMail(opts = {}, callback = noop) {
-    _debug(this.debug, '[sendMail] [attempt] To:', opts.to);
+  async sendMail(opts = {}) {
+    this.__debug('[sendMail]', opts);
     if (!opts.html && !opts.text) {
-      throw new Error('`html` nor `text` field is presented, at least one of those fields is required');
+      throw new Error('[mail-time] [sendMail] `html` nor `text` field is present, at least one of those fields is required');
     }
 
-    if (!opts.sendAt || Object.prototype.toString.call(opts.sendAt) !== '[object Date]') {
-      opts.sendAt = new Date();
+    let sendAt = opts.sendAt;
+    if (sendAt instanceof Date) {
+      sendAt = +sendAt;
     }
-
-    if (typeof opts.template !== 'string') {
-      opts.template = false;
+    if (typeof sendAt !== 'number' || !Number.isFinite(sendAt)) {
+      sendAt = Date.now();
     }
 
-    if (typeof opts.concatSubject !== 'string') {
-      opts.concatSubject = false;
-    }
+    const template = (typeof opts.template === 'string') ? opts.template : false;
+    const concatSubject = (typeof opts.concatSubject === 'string') ? opts.concatSubject : false;
 
-    let _sendAt = opts.sendAt;
-    const _template = opts.template;
-    const _concatSubject = opts.concatSubject;
-    delete opts.sendAt;
-    delete opts.template;
-    delete opts.concatSubject;
+    const mailOptions = { ...opts };
+    delete mailOptions.sendAt;
+    delete mailOptions.template;
+    delete mailOptions.concatSubject;
 
-    if (typeof opts.to !== 'string' && (!(opts.to instanceof Array) || !opts.to.length)) {
-      throw new Error('[mail-time] `mailOptions.to` is required and must be a string or non-empty Array');
+    if (typeof mailOptions.to !== 'string' && (!Array.isArray(mailOptions.to) || !mailOptions.to.length)) {
+      throw new Error('[mail-time] [sendMail] `mailOptions.to` is required and must be a string or non-empty Array');
     }
 
     if (this.concatEmails) {
-      _sendAt = new Date(+_sendAt + this.concatThrottling);
-      this.collection.findOne({
-        to: opts.to,
-        isSent: false,
-        sendAt: {
-          $lte: _sendAt
-        }
-      }, {
-        projection: {
-          _id: 1,
-          mailOptions: 1
-        }
-      }).then((task) => {
-        if (task) {
-          const queue = task.mailOptions || [];
+      sendAt = sendAt + this.concatDelay;
+      const task = await this.queue.getPendingTo(mailOptions.to, sendAt);
 
-          for (let i = 0; i < queue.length; i++) {
-            if (equals(queue[i], opts)) {
-              return;
-            }
-          }
+      if (task) {
+        const pendingMailOptions = task.mailOptions || [];
 
-          queue.push(opts);
-          this.collection.updateOne({
-            _id: task._id
-          }, {
-            $set: {
-              mailOptions: queue
-            }
-          }).then(() => {
-            const _id = task._id.toHexString();
-            if (!this.callbacks[_id]) {
-              this.callbacks[_id] = [];
-            }
-            this.callbacks[_id].push(callback);
-          }).catch(mongoErrorHandler);
-          return;
+        for (let i = 0; i < pendingMailOptions.length; i++) {
+          if (equals(pendingMailOptions[i], mailOptions)) {
+            return task.uuid;
+          }
         }
 
-        this.___addToQueue({
-          sendAt: _sendAt,
-          template: _template,
-          mailOptions: opts,
-          concatSubject: _concatSubject
-        }, callback);
-      }).catch(mongoErrorHandler);
-
-      return;
+        const appended = await this.queue.update(task, {
+          appendMailOption: mailOptions,
+        });
+        if (appended) {
+          return task.uuid;
+        }
+      }
     }
 
-    this.___addToQueue({
-      sendAt: _sendAt,
-      template: _template,
-      mailOptions: opts,
-      concatSubject: _concatSubject
-    }, callback);
+    return await this.___addToQueue({
+      sendAt,
+      template,
+      concatSubject,
+      mailOptions,
+    });
+  }
 
-    return;
+  /**
+   * @async
+   * @memberOf MailTime
+   * @name cancel
+   * @description alias of `cancelMail`
+   * @param {string|Promise<string>} uuid - uuid returned from `send` or `sendMail`
+   * @returns {Promise<boolean>} returns `true` if cancelled or `false` if not found was sent or was cancelled previously
+   */
+  async cancel(uuid) {
+    this.__debug('[cancel]', uuid);
+    return await this.cancelMail(uuid);
   }
 
   /**
+   * @async
+   * @memberOf MailTime
+   * @name cancelMail
+   * @description remove email from the queue or mark as `isCancelled`
+   * @param {string|Promise<string>} uuid - uuid returned from `send` or `sendMail`
+   * @returns {Promise<boolean>} returns `true` if cancelled or `false` if not found was sent or was cancelled previously
+   */
+  async cancelMail(uuid) {
+    this.__debug('[cancelMail]', uuid);
+    const resolved = (uuid && typeof uuid.then === 'function') ? await uuid : uuid;
+    return await this.queue.cancel(resolved);
+  }
+
+  /**
+   * @async
+   * @internal
    * @memberOf MailTime
    * @name ___handleError
-   * @param task  {Object} - Email task record form Mongo
-   * @param error {mix}    - Error String/Object/Error
-   * @param info  {Object} - Info object returned from nodemailer
-   * @returns {void}
+   * @description Handle runtime errors and pass to `onError` callback
+   * @param {MailTimeTask} task - Email task record from Storage
+   * @param {unknown} error - Error String/Object/Error
+   * @param {object} info - Info object returned from nodemailer
+   * @returns {Promise<void 0>}
    */
-  ___handleError(task, error, info) {
+  async ___handleError(task, error, info) {
+    this.__debug('[private handleError]', { task, error, info });
     if (!task) {
       return;
     }
 
     if (task.tries >= this.maxTries) {
+      this.___finalizeRejected(task, info);
+
+      const leaseRemove = __leaseRemoveOpts(task);
+      const leaseUpdate = __withLease(task, {
+        isSent: false,
+        isFailed: true,
+        isSending: false,
+        sendingAt: 0,
+        mailOptions: task.mailOptions,
+      });
+
+      let finalized = false;
       if (!this.keepHistory) {
-        this.collection.deleteOne({
-          _id: task._id
-        }).catch(mongoErrorHandler);
+        finalized = await this.queue.remove(task, leaseRemove);
+      } else {
+        finalized = await this.queue.update(task, leaseUpdate);
       }
 
-      _debug(this.debug, `Giving up trying send email after ${task.tries} attempts to: `, task.mailOptions[0].to, error);
-      this.___triggerCallbacks(error, task, info);
+      if (!finalized) {
+        this.__debug('[private handleError] lease lost before final failure update, skipping onError', task.uuid);
+        return;
+      }
+
+      // Persist first, then mirror to in-memory task — a superseded worker must not lie to onError.
+      task.isSent = false;
+      task.isFailed = true;
+      task.isSending = false;
+
+      this.__debug(`[private handleError] Giving up trying send email after ${task.tries} attempts to: `, task.mailOptions[0].to, error);
+      this.onError(error, task, info);
       return;
     }
 
     let transportIndex = task.transport;
 
     if (this.strategy === 'backup' && this.transports.length > 1 && (task.tries % this.failsToNext) === 0) {
-      ++transportIndex;
-      if (transportIndex > this.transports.length - 1) {
-        transportIndex = 0;
-      }
+      transportIndex = this.___nextHealthyTransport(transportIndex);
     }
 
-    this.collection.updateOne({
-      _id: task._id
-    }, {
-      $set: {
-        isSent: false,
-        sendAt: new Date(Date.now() + this.interval),
-        transport: transportIndex
-      }
-    }).catch(mongoErrorHandler);
+    const released = await this.queue.update(task, __withLease(task, {
+      isSending: false,
+      sendingAt: 0,
+      sendAt: Date.now() + this.retryDelay,
+      transport: transportIndex,
+    }));
+
+    if (!released) {
+      this.__debug('[private handleError] lease lost before retry release, skipping', task.uuid);
+      return;
+    }
 
-    _debug(this.debug, `Next re-send attempt at ${new Date(Date.now() + this.interval)}: #${task.tries}/${this.maxTries}, transport #${transportIndex} to: `, task.mailOptions[0].to, error);
+    this.__debug(`[private handleError] Next re-send attempt at ${new Date(Date.now() + this.retryDelay)}: #${task.tries}/${this.maxTries}, transport #${transportIndex} to: `, task.mailOptions[0].to, error);
   }
 
   /**
+   * @async
+   * @internal
    * @memberOf MailTime
    * @name ___addToQueue
-   * @param opts               {Object}   - Letter options with next properties:
-   * @param opts.sendAt        {Date}     - When email should be sent
-   * @param opts.template      {String}   - Email template
-   * @param opts.mailOptions   {Object}   - MailOptions according to NodeMailer lib
-   * @param opts.concatSubject {String}   - Email subject used when sending multiple concatenated emails
-   * @param callback           {Function} - [OPTIONAL] Callback function
-   * @returns {void}
+   * @description Prepare task's object and push to the queue
+   * @param {{ sendAt: number, template: string | false, mailOptions: MailTimeMailOptions, concatSubject: string | false }} opts - Email options
+   * @returns {Promise<string>} message uuid
    */
-  ___addToQueue(opts, callback) {
-    _debug(this.debug, '[sendMail] [adding to queue] To:', opts.mailOptions.to);
+  async ___addToQueue(opts) {
+    this.__debug('[private addToQueue]', opts);
+    let transportIndex = this.transport;
+    if (this.strategy === 'balancer' && this.transports.length > 0) {
+      transportIndex = this.___nextHealthyTransport(this.transport);
+      this.transport = transportIndex;
+    }
     const task = {
+      uuid: randomUUID(),
       tries: 0,
       isSent: false,
       sendAt: opts.sendAt,
+      isFailed: false,
+      isSending: false,
+      sendingAt: 0,
       template: opts.template,
-      transport: this.transport,
+      transport: transportIndex,
+      isCancelled: false,
       mailOptions: [opts.mailOptions],
-      concatSubject: opts.concatSubject
+      concatSubject: opts.concatSubject,
     };
 
     if (this.concatEmails) {
       task.to = opts.mailOptions.to;
     }
 
-    this.collection.insertOne(task).then((r) => {
-      const _id = r.insertedId.toHexString();
-      if (!this.callbacks[_id]) {
-        this.callbacks[_id] = [];
-      }
-      this.callbacks[_id].push(callback);
-    }).catch(mongoErrorHandler);
+    await this.queue.push(task);
+    return task.uuid;
   }
 
   /**
+   * @internal
    * @memberOf MailTime
    * @name ___render
-   * @param string       {String} - Template with Spacebars/Blaze/Mustache-like placeholders
-   * @param replacements {Object} - Blaze/Mustache-like helpers Object
-   * @returns {String}
+   * @description Render Mustache-like placeholders
+   * @param {string} _string - Template with Mustache-like placeholders
+   * @param {Record<string, any>} replacements - Blaze/Mustache-like helpers Object
+   * @returns {string}
    */
   ___render(_string, replacements) {
-    let i;
     let string = _string;
-    const matchHTML = string.match(/\{{3}\s?([a-zA-Z0-9\-\_]+)\s?\}{3}/g);
+    const matchHTML = string.match(/\{{3}\s?([a-zA-Z0-9\-_]+)\s?\}{3}/g);
     if (matchHTML) {
-      for (i = 0; i < matchHTML.length; i++) {
-        if (replacements[matchHTML[i].replace('{{{', '').replace('}}}', '').trim()]) {
-          string = string.replace(matchHTML[i], replacements[matchHTML[i].replace('{{{', '').replace('}}}', '').trim()]);
+      for (let i = 0; i < matchHTML.length; i++) {
+        const key = matchHTML[i].slice(3, -3).trim();
+        if (Object.hasOwn(replacements, key) && replacements[key] !== null && replacements[key] !== void 0) {
+          string = string.replace(matchHTML[i], `${replacements[key]}`);
         }
       }
     }
 
-    const matchStr = string.match(/\{{2}\s?([a-zA-Z0-9\-\_]+)\s?\}{2}/g);
+    const matchStr = string.match(/\{{2}\s?([a-zA-Z0-9\-_]+)\s?\}{2}/g);
     if (matchStr) {
-      for (i = 0; i < matchStr.length; i++) {
-        if (replacements[matchStr[i].replace('{{', '').replace('}}', '').trim()]) {
-          string = string.replace(matchStr[i], replacements[matchStr[i].replace('{{', '').replace('}}', '').trim()].replace(/<(?:.|\n)*?>/gm, ''));
+      for (let i = 0; i < matchStr.length; i++) {
+        const key = matchStr[i].slice(2, -2).trim();
+        if (Object.hasOwn(replacements, key) && replacements[key] !== null && replacements[key] !== void 0) {
+          string = string.replace(matchStr[i], `${replacements[key]}`.replace(/<(?:.|\n)*?>/gm, ''));
         }
       }
     }
@@ -635,20 +706,476 @@ export default class MailTime {
   }
 
   /**
+   * @internal
    * @memberOf MailTime
-   * @name ___triggerCallbacks
-   * @param error  {mix}    - Error thrown during sending email
-   * @param task   {Object} - Task record from mongodb
-   * @param info   {Object} - Info object returned from NodeMailer's `sendMail` method
-   * @returns {void 0}
+   * @name ___compileMailOpts
+   * @description Run various checks, compile options, and render template
+   * @param {MailTimeTransport} transport - Current transport
+   * @param {MailTimeTask} task - Email task record from Storage
+   * @returns {MailTimeMailOptions}
    */
-  ___triggerCallbacks(error, task, info) {
-    const _id = task._id.toHexString();
-    if (this.callbacks[_id] && this.callbacks[_id].length) {
-      this.callbacks[_id].forEach((cb, i) => {
-        cb(error, info, task?.mailOptions?.[i]);
+  ___compileMailOpts(transport, task) {
+    if (!transport) {
+      throw new Error('[mail-time] [sendMail] [___compileMailOpts] {transport} is not available or misconfigured!');
+    }
+
+    let compiledOpts = {};
+
+    if (isPlainObject(transport._options) && isPlainObject(transport._options.mailOptions)) {
+      compiledOpts = deepMerge(compiledOpts, transport._options.mailOptions);
+    }
+
+    if (isPlainObject(transport.options) && isPlainObject(transport.options.mailOptions)) {
+      compiledOpts = deepMerge(compiledOpts, transport.options.mailOptions);
+    }
+
+    compiledOpts.html ??= '';
+    compiledOpts.text ??= '';
+    compiledOpts.subject ??= '';
+
+    const mailOptionsList = task.mailOptions || [];
+    const isMulti = mailOptionsList.length > 1;
+
+    for (let i = 0; i < mailOptionsList.length; i++) {
+      const mailOption = { ...mailOptionsList[i] };
+
+      if (mailOption.html) {
+        const rendered = this.___render(mailOption.html, mailOption);
+        if (isMulti) {
+          compiledOpts.html += this.___render(this.concatDelimiter, mailOption) + rendered;
+        } else {
+          compiledOpts.html = rendered;
+        }
+        delete mailOption.html;
+      }
+
+      if (mailOption.text) {
+        const rendered = this.___render(mailOption.text, mailOption);
+        if (isMulti) {
+          compiledOpts.text += '\r\n' + rendered;
+        } else {
+          compiledOpts.text = rendered;
+        }
+        delete mailOption.text;
+      }
+
+      compiledOpts = deepMerge(compiledOpts, mailOption);
+    }
+
+    if (compiledOpts.html && (task.template || this.template)) {
+      compiledOpts.html = this.___render((task.template || this.template), compiledOpts);
+    }
+
+    if (isMulti) {
+      const rawSubject = task.concatSubject || this.concatSubject || compiledOpts.subject;
+      compiledOpts.subject = this.___render(rawSubject, { count: mailOptionsList.length });
+    }
+
+    if (!compiledOpts.from && this.from) {
+      compiledOpts.from = this.from(transport);
+    }
+
+    const acceptedSet = collectAcceptedSet(task);
+    if (acceptedSet.size > 0) {
+      compiledOpts.to = filterAddressField(compiledOpts.to, acceptedSet);
+      compiledOpts.cc = filterAddressField(compiledOpts.cc, acceptedSet);
+      compiledOpts.bcc = filterAddressField(compiledOpts.bcc, acceptedSet);
+    }
+
+    return compiledOpts;
+  }
+
+  /**
+   * @internal
+   * @memberOf MailTime
+   * @name ___trackAcceptedRecipients
+   * @description Append newly-accepted addresses to each mailOption's `accepted` list
+   * @param {MailTimeTask} task - Email task record from Storage
+   * @param {string[]} acceptedAddrs - Lowercased addresses confirmed by transport
+   * @returns {void}
+   */
+  ___trackAcceptedRecipients(task, acceptedAddrs) {
+    if (!Array.isArray(task?.mailOptions) || acceptedAddrs.length === 0) {
+      return;
+    }
+    const acceptedSet = new Set(acceptedAddrs);
+    for (const mo of task.mailOptions) {
+      if (!Array.isArray(mo.accepted)) {
+        mo.accepted = [];
+      }
+      const moRecipients = new Set(mailOptionRecipients(mo));
+      if (moRecipients.size === 0) {
+        continue;
+      }
+      const alreadyAccepted = new Set(mo.accepted.map((a) => typeof a === 'string' ? a.toLowerCase() : a));
+      for (const addr of acceptedSet) {
+        if (moRecipients.has(addr) && !alreadyAccepted.has(addr)) {
+          mo.accepted.push(addr);
+          alreadyAccepted.add(addr);
+        }
+      }
+    }
+  }
+
+  /**
+   * @internal
+   * @memberOf MailTime
+   * @name ___finalizeRejected
+   * @description Populate each mailOption's `rejected` list with addresses that never delivered
+   * @param {MailTimeTask} task - Email task record from Storage
+   * @param {object} info - Info object from the last nodemailer attempt
+   * @returns {void}
+   */
+  ___finalizeRejected(task, info) {
+    if (!Array.isArray(task?.mailOptions)) {
+      return;
+    }
+    const errorMap = buildRejectionErrorMap(info);
+    for (const mo of task.mailOptions) {
+      const moAccepted = new Set((mo.accepted || []).map((a) => typeof a === 'string' ? a.toLowerCase() : a));
+      const seen = new Set();
+      const rejected = [];
+      for (const addr of mailOptionRecipients(mo)) {
+        if (moAccepted.has(addr) || seen.has(addr)) {
+          continue;
+        }
+        seen.add(addr);
+        rejected.push({
+          address: addr,
+          error: errorMap.get(addr) || 'Recipient rejected by transport',
+        });
+      }
+      mo.rejected = rejected;
+    }
+  }
+
+  /**
+   * @async
+   * @internal
+   * @memberOf MailTime
+   * @name ___dispatch
+   * @description Queue full-lifecycle send for `task` under the bounded send pool. Resolves as soon as a pool slot is acquired and the send has started — the SMTP roundtrip continues in the background so the adapter's `iterate` can move on to the next due row and the JoSk lease can be released. Call `await mailTime.drain()` to await in-flight sends; use `destroy({ drain: true })` for graceful shutdown.
+   * @param {MailTimeTask} task - email's task object from Storage
+   * @returns {Promise<void 0>}
+   */
+  async ___dispatch(task) {
+    if (this.__isDestroyed) {
+      return;
+    }
+    if (!task || task.isSent === true || task.isFailed === true || task.isCancelled === true) {
+      return;
+    }
+    if (this.__inFlight.has(task.uuid)) {
+      this.__debug('[private dispatch] already in-flight on this instance, skipping', task.uuid);
+      return;
+    }
+    this.__inFlight.add(task.uuid);
+    await this.__pool.dispatch(async () => {
+      try {
+        if (this.__isDestroyed) {
+          return;
+        }
+        await this.___send(task);
+      } finally {
+        this.__inFlight.delete(task.uuid);
+      }
+    });
+  }
+
+  /**
+   * @async
+   * @internal
+   * @memberOf MailTime
+   * @name ___send
+   * @description Full send lifecycle for a single task: atomic claim (`isSending=true, sendingAt=now, tries=tries+1`), SMTP roundtrip, completion. Returns when the lifecycle ends.
+   * @param {MailTimeTask} task - email's task object from Storage
+   * @returns {Promise<void 0>}
+   */
+  async ___send(task) {
+    this.__debug('[private send]', task);
+    try {
+      if (!task || task.isSent === true || task.isFailed === true || task.isCancelled === true) {
+        return;
+      }
+
+      const tries = task.tries + 1;
+      const sendingAt = Date.now();
+      let isClaimed = false;
+      try {
+        isClaimed = await this.queue.update(task, {
+          isSending: true,
+          sendingAt,
+          tries,
+        });
+      } catch (claimError) {
+        logError('[private send] [claim] storage error during atomic claim', claimError);
+        return;
+      }
+
+      if (!isClaimed) {
+        this.__debug('[private send] [queue.update] Stale claim, skipping', task.uuid);
+        return;
+      }
+
+      task.tries = tries;
+      task.isSending = true;
+      task.sendingAt = sendingAt;
+
+      let transportIndex = task.transport;
+      if (!this.___isHealthyTransport(transportIndex)) {
+        transportIndex = this.___nextHealthyTransport(transportIndex);
+        task.transport = transportIndex;
+      }
+      const transport = this.transports[transportIndex];
+
+      const compiledOpts = this.___compileMailOpts(transport, task);
+
+      await new Promise((resolve) => {
+        transport.sendMail(compiledOpts, async (error, info) => {
+          this.__debug('[private send] [sending]', { error, info });
+          try {
+            if (error) {
+              await this.___handleError(task, error, info);
+              return;
+            }
+
+            const acceptedAddrs = Array.isArray(info?.accepted)
+              ? info.accepted.map(extractEmail).filter((addr) => typeof addr === 'string')
+              : [];
+
+            if (acceptedAddrs.length === 0) {
+              await this.___handleError(task, new Error('Message not accepted or Greeting never received'), info);
+              return;
+            }
+
+            this.___trackAcceptedRecipients(task, acceptedAddrs);
+
+            const allRecipients = collectAllRecipients(task);
+            const allAccepted = collectAcceptedSet(task);
+            let isFullyDelivered = true;
+            for (const addr of allRecipients) {
+              if (!allAccepted.has(addr)) {
+                isFullyDelivered = false;
+                break;
+              }
+            }
+
+            if (isFullyDelivered) {
+              this.__debug(`email successfully sent, attempts: #${task.tries}, transport #${transportIndex} to: `, compiledOpts.to);
+
+              const leaseRemove = __leaseRemoveOpts(task);
+              const leaseUpdate = __withLease(task, {
+                isSent: true,
+                isSending: false,
+                sendingAt: 0,
+                mailOptions: task.mailOptions,
+              });
+
+              let completed = false;
+              if (!this.keepHistory) {
+                completed = await this.queue.remove(task, leaseRemove);
+              } else {
+                completed = await this.queue.update(task, leaseUpdate);
+              }
+
+              if (!completed) {
+                this.__debug('[private send] lease lost before success completion, skipping onSent', task.uuid);
+                return;
+              }
+
+              // Persist first, then mirror to in-memory task — a superseded worker must not lie to onSent.
+              task.isSent = true;
+              task.isSending = false;
+              task.sendingAt = 0;
+              this.onSent(task, info);
+              return;
+            }
+
+            if (task.tries >= this.maxTries) {
+              this.___finalizeRejected(task, info);
+
+              const leaseRemove = __leaseRemoveOpts(task);
+              const leaseUpdate = __withLease(task, {
+                isSent: false,
+                isFailed: true,
+                isSending: false,
+                sendingAt: 0,
+                mailOptions: task.mailOptions,
+              });
+
+              let finalized = false;
+              if (!this.keepHistory) {
+                finalized = await this.queue.remove(task, leaseRemove);
+              } else {
+                finalized = await this.queue.update(task, leaseUpdate);
+              }
+
+              if (!finalized) {
+                this.__debug('[private send] lease lost before partial-failure completion, skipping onError', task.uuid);
+                return;
+              }
+
+              // Persist first, then mirror to in-memory task — a superseded worker must not lie to onError.
+              task.isSent = false;
+              task.isFailed = true;
+              task.isSending = false;
+
+              const rejectedAddrs = [];
+              for (const mo of task.mailOptions) {
+                for (const r of (mo.rejected || [])) {
+                  rejectedAddrs.push(r.address);
+                }
+              }
+              const partialError = new Error(`Recipients rejected after ${task.tries} attempts: ${rejectedAddrs.join(', ')}`);
+              this.__debug('[private send] Partial delivery exhausted retries; rejected: ', rejectedAddrs);
+              this.onError(partialError, task, info);
+              return;
+            }
+
+            const nextSendAt = Date.now() + this.retryDelay;
+            const released = await this.queue.update(task, __withLease(task, {
+              isSending: false,
+              sendingAt: 0,
+              sendAt: nextSendAt,
+              mailOptions: task.mailOptions,
+            }));
+            if (!released) {
+              this.__debug('[private send] lease lost before partial retry release', task.uuid);
+              return;
+            }
+            this.__debug(`[private send] Partial delivery, next attempt at ${new Date(nextSendAt)}: #${task.tries}/${this.maxTries} for remaining recipients`);
+          } finally {
+            resolve();
+          }
+        });
       });
+    } catch (e) {
+      logError('Exception during runtime:', e);
+      await this.___handleError(task, e, {});
+    }
+  }
+
+  /**
+   * @internal
+   * @memberOf MailTime
+   * @name ___iterate
+   * @description JoSk handler — claim and dispatch due tasks. Returns as soon as the scan finishes so the JoSk lease is released; in-flight SMTP work continues in the background pool.
+   * @returns {Promise<void>|void}
+   */
+  async ___iterate() {
+    this.__debug('[private iterate]');
+    if (this.__isDestroyed) {
+      return;
+    }
+    const limit = this.mode === 'one' ? 1 : Infinity;
+    return await this.queue.iterate({
+      limit,
+      sendingTimeout: this.sendingTimeout,
+    });
+  }
+
+  /**
+   * @async
+   * @internal
+   * @memberOf MailTime
+   * @name ___ready
+   * @description Internal storage readiness gate
+   * @returns {Promise<MailTime>}
+   */
+  async ___ready() {
+    if (typeof this.queue.ready === 'function') {
+      await this.queue.ready();
+    }
+
+    if (this.__schedulerTimer) {
+      await this.__schedulerTimer;
+    }
+
+    const pingResult = await this.ping();
+    if (pingResult.status !== 'OK') {
+      throw new Error('[mail-time] [MailTime#ready] can not connect to storage, make sure it is available and properly configured', { cause: pingResult.error });
+    }
+
+    if (this.type === 'server' && this.verifyTransports && this.transports.length > 0) {
+      await this.___verifyTransports();
+    }
+
+    return this;
+  }
+
+  /**
+   * @async
+   * @internal
+   * @memberOf MailTime
+   * @name ___verifyTransports
+   * @description Probe each transport's `verify()` once at startup. Failing transports are marked unusable and skipped during rotation; the failure is surfaced through `onError(error, null, { transportIndex, phase: 'verify' })`. Throws if every transport fails — there is nothing left that could deliver.
+   * @returns {Promise<void>}
+   */
+  async ___verifyTransports() {
+    this.__debug('[private verifyTransports]');
+    const results = await Promise.all(this.transports.map(async (transport, index) => {
+      if (!transport || typeof transport.verify !== 'function') {
+        return { index, ok: true };
+      }
+      try {
+        await Promise.resolve(transport.verify());
+        return { index, ok: true };
+      } catch (error) {
+        return { index, ok: false, error };
+      }
+    }));
+
+    for (const r of results) {
+      if (r.ok) {
+        continue;
+      }
+      this.__unhealthyTransports.add(r.index);
+      logError(`[mail-time] [verifyTransports] transport #${r.index} failed verification`, r.error);
+      this.onError(r.error, null, { transportIndex: r.index, phase: 'verify' });
+    }
+
+    if (this.__unhealthyTransports.size === this.transports.length) {
+      throw new Error(`[mail-time] [MailTime#ready] all ${this.transports.length} transport(s) failed verification — nothing can be delivered`);
+    }
+
+    if (this.__unhealthyTransports.has(this.transport)) {
+      this.transport = this.___nextHealthyTransport(this.transport);
+    }
+  }
+
+  /**
+   * @internal
+   * @memberOf MailTime
+   * @name ___isHealthyTransport
+   * @description Return true when the transport at `index` has not been marked unusable by verification.
+   * @param {number} index
+   * @returns {boolean}
+   */
+  ___isHealthyTransport(index) {
+    return !this.__unhealthyTransports.has(index);
+  }
+
+  /**
+   * @internal
+   * @memberOf MailTime
+   * @name ___nextHealthyTransport
+   * @description Advance at least one position from `fromIdx` and return the next healthy transport index (wrapping). Falls back to `fromIdx` if no healthy transport exists.
+   * @param {number} fromIdx
+   * @returns {number}
+   */
+  ___nextHealthyTransport(fromIdx) {
+    if (this.transports.length === 0) {
+      return fromIdx;
     }
-    delete this.callbacks[_id];
+    let next = fromIdx;
+    for (let i = 0; i < this.transports.length; i++) {
+      next = (next + 1) % this.transports.length;
+      if (this.___isHealthyTransport(next)) {
+        return next;
+      }
+    }
+    return fromIdx;
   }
 }
+
+export { MailTime, MongoQueue, RedisQueue, PostgresQueue, mailTimePreset, presets, presetNames };