@xeplr/utils 1.0.0 → 1.0.2

package/index.js

@@ -1,17 +1,23 @@
-const { sendEmail, configureEmail } = require('./lib/email');
+const { sendEmail, configureEmail, emailConfigFromEnv, smtpFromEnv, configureFromEnv } = require('./lib/email');
 const { configureLogger, createSession, log, closeSession, getSessionLogs } = require('./lib/logger');
 const { generateId, formatDbDateTime, mysqlDateTime } = require('./lib/helpers');
 const { respond, sanitizeError } = require('./lib/response');
 const cache = require('./lib/cache');
 const Queue = require('./lib/queue');
+// Which SQL failures are worth trying again — see lib/sql-error.js.
+const { classifySqlError, isRetryableSqlError } = require('./lib/sql-error');
 const FileUploader = require('./lib/fileUploader');
 const RateLimiter = require('./lib/rateLimiter');
 const sms = require('./lib/sms');
+const otp = require('./lib/otp');
 
 module.exports = {
   // Email
   sendEmail,
   configureEmail,
+  emailConfigFromEnv,
+  smtpFromEnv,
+  configureFromEnv,
 
   // Logger client
   configureLogger,
@@ -35,6 +41,10 @@ module.exports = {
   // Queue
   Queue,
 
+  // SQL error classification (retry decisions, and the code a log line carries)
+  classifySqlError,
+  isRetryableSqlError,
+
   // File Uploader
   FileUploader,
 
@@ -42,5 +52,8 @@ module.exports = {
   RateLimiter,
 
   // SMS
-  sms
+  sms,
+
+  // OTP (uses sms above for delivery)
+  otp
 };

package/isomorphic/crypto.js

@@ -120,4 +120,63 @@ async function decrypt(encrypted, key) {
   return new TextDecoder().decode(decrypted);
 }
 
-module.exports = { encrypt, decrypt };
+/**
+ * Same as encrypt(), but returns the salt separately instead of packing it
+ * into the payload — for callers that store salt in its own column/field
+ * (e.g. to keep the ciphertext opaque even to something inspecting schema,
+ * or to swap in a different encryption backend later that takes salt as an
+ * explicit input rather than embedding it).
+ *
+ * @param {string} plaintext
+ * @param {string} key - Passphrase
+ * @param {string} [salt] - Base64 salt to reuse (e.g. rotating the ciphertext
+ *   without rotating the salt). Omit to generate a new one.
+ * @returns {Promise<{salt: string, ciphertext: string}>} both base64
+ */
+async function encryptSplit(plaintext, key, salt) {
+  var saltBytes = salt ? fromBase64(salt) : new Uint8Array(16);
+  if (!salt) getRandomValues(saltBytes);
+  var iv = new Uint8Array(12);
+  getRandomValues(iv);
+
+  var cryptoKey = await deriveKey(key, saltBytes);
+  var enc = new TextEncoder();
+  var ciphertext = await getSubtle().encrypt(
+    { name: 'AES-GCM', iv: iv },
+    cryptoKey,
+    enc.encode(plaintext)
+  );
+
+  // Pack: iv (12) + ciphertext — salt travels separately.
+  var packed = new Uint8Array(12 + ciphertext.byteLength);
+  packed.set(iv, 0);
+  packed.set(new Uint8Array(ciphertext), 12);
+
+  return { salt: toBase64(saltBytes), ciphertext: toBase64(packed) };
+}
+
+/**
+ * Counterpart to encryptSplit() — salt passed in explicitly rather than read
+ * from the payload.
+ *
+ * @param {string} ciphertext - Base64 payload from encryptSplit()
+ * @param {string} key - Passphrase
+ * @param {string} salt - Base64 salt from encryptSplit()
+ * @returns {Promise<string>} Decrypted plaintext
+ */
+async function decryptSplit(ciphertext, key, salt) {
+  var packed = fromBase64(ciphertext);
+  var iv = packed.slice(0, 12);
+  var data = packed.slice(12);
+
+  var cryptoKey = await deriveKey(key, fromBase64(salt));
+  var decrypted = await getSubtle().decrypt(
+    { name: 'AES-GCM', iv: iv },
+    cryptoKey,
+    data
+  );
+
+  return new TextDecoder().decode(decrypted);
+}
+
+module.exports = { encrypt, decrypt, encryptSplit, decryptSplit };

package/lib/cache.js

@@ -1,4 +1,23 @@
-const Redis = require('ioredis');
+// `ioredis` is an OPTIONAL peer dependency — nothing in xeplr-utils
+// requires Redis unless you actually use the cache. We lazy-require it so
+// projects that never touch cache/queue/sessions never have to install it.
+// If they DO reach for cache without installing ioredis, throw a message
+// that names the fix, not a raw "Cannot find module" from deep in node.
+let Redis = null;
+function loadRedis() {
+  if (Redis) return Redis;
+  try { Redis = require('ioredis'); return Redis; }
+  catch (e) {
+    var err = new Error(
+      "@xeplr/utils/lib/cache: 'ioredis' is not installed. Run `npm install ioredis` " +
+      "in your project. It's an optional peer dependency — only required if you use " +
+      "the cache, queue, or any session-backed feature (xeplr-auth sessions, SSE " +
+      "tickets, email queue)."
+    );
+    err.cause = e;
+    throw err;
+  }
+}
 
 let _client = null;
 let _config = {};
@@ -38,6 +57,7 @@ function configureCache(config = {}) {
 
 function getClient() {
   if (_client) return _client;
+  const RedisCtor = loadRedis();
 
   const opts = {
     host: _config.host || process.env.REDIS_HOST || '127.0.0.1',
@@ -64,7 +84,7 @@ function getClient() {
     // For extreme throughput, use Cluster mode instead.
   };
 
-  _client = new Redis(opts);
+  _client = new RedisCtor(opts);
 
   _client.on('error', (err) => {
     // Silently handle — don't crash the server if Redis is down

package/lib/email.js

@@ -1,4 +1,19 @@
-const nodemailer = require('nodemailer');
+// `nodemailer` is an optional peer dep — lazy-loaded so projects that
+// don't send email don't have to install it (or its transitive deps).
+let _nodemailer = null;
+function loadNodemailer() {
+  if (_nodemailer) return _nodemailer;
+  try { _nodemailer = require('nodemailer'); return _nodemailer; }
+  catch (e) {
+    var err = new Error(
+      "@xeplr/utils/lib/email: 'nodemailer' is not installed. Run `npm install nodemailer` " +
+      "in your project. It's an optional peer dependency — only required if you send email."
+    );
+    err.cause = e;
+    throw err;
+  }
+}
+
 const fs = require('fs');
 const path = require('path');
 
@@ -10,7 +25,7 @@ let _deadLetterQueue = null;
  * Configure the email service.
  * @param {object} config
  * @param {string} config.provider - 'smtp' | 'aws' | 'azure' | 'brevo'
- * @param {object} [config.smtp] - { host, port, user, pass, from }
+ * @param {object} [config.smtp] - { host, port, user, pass, from, secure }
  * @param {object} [config.aws] - { region, accessKeyId, secretAccessKey, from }
  * @param {object} [config.azure] - { connectionString, from }
  * @param {object} [config.brevo] - { apiKey, fromEmail, fromName }
@@ -101,19 +116,62 @@ function buildAttachments(attachments) {
 }
 
 async function sendViaSMTP(to, subject, html, cc, attachments) {
-  var cfg = getConfig().smtp;
-  var transporter = nodemailer.createTransport({
+  var cfg = getConfig().smtp || {};
+  var port = _num(cfg.port, 587);
+  // 465 is implicit TLS from the first byte; 587 and 25 start in the clear and
+  // negotiate STARTTLS. A hardcoded false made every 465 relay fail on the
+  // handshake, so infer from the port unless it is stated.
+  var secure = cfg.secure === undefined || cfg.secure === null ? port === 465 : !!cfg.secure;
+
+  // Everything the caller set is forwarded; everything it did not is absent,
+  // so nodemailer's defaults stand. Same shape as the email-send action's
+  // connection object, so one SMTP server is described identically whether it
+  // is configured on a workflow step or in this install's env.
+  var transport = _compact({
     host: cfg.host,
-    port: cfg.port,
-    secure: false,
-    auth: { user: cfg.user, pass: cfg.pass }
+    port: port,
+    secure: secure,
+    requireTLS: cfg.requireTLS,
+    ignoreTLS: cfg.ignoreTLS,
+    name: cfg.name,
+    authMethod: cfg.authMethod,
+    connectionTimeout: cfg.connectionTimeout,
+    greetingTimeout: cfg.greetingTimeout,
+    socketTimeout: cfg.socketTimeout,
+    pool: cfg.pool,
+    maxConnections: cfg.maxConnections,
+    maxMessages: cfg.maxMessages,
+    logger: cfg.debug ? undefined : false,
+    debug: cfg.debug,
+    tls: cfg.tls && Object.keys(cfg.tls).length ? cfg.tls : undefined
   });
+  if (cfg.user || cfg.pass) transport.auth = _compact({ user: cfg.user, pass: cfg.pass });
+
+  // Unrecognised options last, so a server that needs something this library
+  // does not name is still reachable without editing this library. `tls` is
+  // merged a level deeper instead of replaced — SMTP_TLS_* and a tls block in
+  // SMTP_OPTIONS are both ways of saying the same thing, and dropping one
+  // because the other was set would be a silent downgrade.
+  if (cfg.options) {
+    var extraTls = cfg.options.tls;
+    Object.keys(cfg.options).forEach(function (k) {
+      if (k !== 'tls') transport[k] = cfg.options[k];
+    });
+    if (extraTls) transport.tls = Object.assign({}, transport.tls, extraTls);
+  }
+
+  var transporter = loadNodemailer().createTransport(transport);
 
   var mailOptions = { from: cfg.from, to, subject, html };
   if (cc && cc.length) mailOptions.cc = cc;
   if (attachments && attachments.length) mailOptions.attachments = buildAttachments(attachments);
 
-  await transporter.sendMail(mailOptions);
+  try {
+    await transporter.sendMail(mailOptions);
+  } finally {
+    // A pooled transport holds sockets open and would keep the process alive.
+    if (typeof transporter.close === 'function') transporter.close();
+  }
 }
 
 async function sendViaAWS(to, subject, html, cc, attachments) {
@@ -122,7 +180,7 @@ async function sendViaAWS(to, subject, html, cc, attachments) {
   // If there are attachments or cc, use SESv2 with raw email via nodemailer
   if ((attachments && attachments.length) || (cc && cc.length)) {
     var { SESv2Client, SendEmailCommand } = require('@aws-sdk/client-sesv2');
-    var transporter = nodemailer.createTransport({ streamTransport: true });
+    var transporter = loadNodemailer().createTransport({ streamTransport: true });
 
     var mailOptions = { from: cfg.from, to, subject, html };
     if (cc && cc.length) mailOptions.cc = cc;
@@ -300,4 +358,119 @@ async function replayDeadLetters() {
   return items.length;
 }
 
-module.exports = { sendEmail, configureEmail, getDeadLetterQueue, replayDeadLetters };
+// ── SMTP from env ───────────────────────────────────────────────────────
+//
+// The same knobs the email-send ACTION already exposes on its connection
+// object (see @xeplr/actions lib/drivers/email/smtp.js), read from env instead
+// of from a workflow step. Kept deliberately open-ended rather than curated
+// per provider: "which SMTP server is this" is not a question this library can
+// answer, and every provider-specific list eventually meets a server that
+// needs one more option. Anything left unset is left OUT of the transport, so
+// nodemailer's own defaults apply.
+
+function _num(v, fallback) {
+  if (v === undefined || v === null || v === '') return fallback;
+  var n = Number(v);
+  return isFinite(n) ? n : fallback;
+}
+
+function _bool(v, fallback) {
+  if (v === undefined || v === null || v === '') return fallback;
+  var t = String(v).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].indexOf(t) !== -1) return true;
+  if (['0', 'false', 'no', 'off'].indexOf(t) !== -1) return false;
+  return fallback;
+}
+
+function _compact(obj) {
+  var out = {};
+  Object.keys(obj || {}).forEach(function (k) {
+    if (obj[k] !== undefined) out[k] = obj[k];
+  });
+  return out;
+}
+
+function smtpFromEnv() {
+  var env = process.env;
+
+  var tls = _compact({
+    rejectUnauthorized: _bool(env.SMTP_TLS_REJECT_UNAUTHORIZED, undefined),
+    servername: env.SMTP_TLS_SERVERNAME || undefined
+  });
+
+  return _compact({
+    host: env.SMTP_HOST,
+    port: _num(env.SMTP_PORT, 587),
+    user: env.SMTP_USER,
+    pass: env.SMTP_PASS,
+    from: env.SMTP_FROM,
+    // Undefined unless stated, so sendViaSMTP infers it from the port.
+    secure: _bool(env.SMTP_SECURE, undefined),
+    requireTLS: _bool(env.SMTP_REQUIRE_TLS, undefined),
+    ignoreTLS: _bool(env.SMTP_IGNORE_TLS, undefined),
+    name: env.SMTP_NAME || undefined,             // EHLO/HELO — some servers are picky
+    authMethod: env.SMTP_AUTH_METHOD || undefined,
+    connectionTimeout: _num(env.SMTP_CONNECTION_TIMEOUT, undefined),
+    greetingTimeout: _num(env.SMTP_GREETING_TIMEOUT, undefined),
+    socketTimeout: _num(env.SMTP_SOCKET_TIMEOUT, undefined),
+    pool: _bool(env.SMTP_POOL, undefined),
+    maxConnections: _num(env.SMTP_MAX_CONNECTIONS, undefined),
+    maxMessages: _num(env.SMTP_MAX_MESSAGES, undefined),
+    debug: _bool(env.SMTP_DEBUG, undefined),
+    tls: Object.keys(tls).length ? tls : undefined,
+    // THE ESCAPE HATCH. Named options cover the common ground; this carries
+    // anything a particular server needs that this library has never heard of
+    // (dkim, proxy, tls.ciphers, a vendor's own flag). Merged last, so it can
+    // also override any of the above.
+    options: _smtpOptionsFromEnv(env.SMTP_OPTIONS)
+  });
+}
+
+// Invalid JSON THROWS rather than being skipped. A typo here would otherwise
+// drop the one option the server actually needed and fail later as a refused
+// connection or, worse, an unencrypted send that looked fine.
+function _smtpOptionsFromEnv(raw) {
+  if (raw === undefined || raw === null || String(raw).trim() === '') return undefined;
+  var parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error('SMTP_OPTIONS is not valid JSON: ' + err.message +
+      ' — expected a JSON object, e.g. {"dkim":{"domainName":"x.com"}}');
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('SMTP_OPTIONS must be a JSON OBJECT of nodemailer transport options, got ' +
+      (Array.isArray(parsed) ? 'an array' : typeof parsed) + '.');
+  }
+  return parsed;
+}
+
+// Build an email config from env (EMAIL_PROVIDER + provider vars). Pure — returns
+// the config or null if no provider is set. The single source for env→email config.
+function emailConfigFromEnv() {
+  var provider = process.env.EMAIL_PROVIDER;
+  if (!provider) return null;
+
+  var config = { provider: provider };
+  if (provider === 'brevo') {
+    config.brevo = {
+      apiKey: process.env.BREVO_API_KEY,
+      fromEmail: process.env.BREVO_FROM_EMAIL,
+      fromName: process.env.BREVO_FROM_NAME
+    };
+  } else if (provider === 'smtp') {
+    config.smtp = smtpFromEnv();
+  }
+  // aws / azure read their own vars here when those providers are used.
+  return config;
+}
+
+// Configure the email sender straight from env. Returns true if a provider was set.
+function configureFromEnv() {
+  var config = emailConfigFromEnv();
+  if (!config) return false;
+  configureEmail(config);
+  return true;
+}
+
+module.exports = { sendEmail, configureEmail, emailConfigFromEnv, smtpFromEnv, configureFromEnv, getDeadLetterQueue, replayDeadLetters };

package/lib/fileUploader.js

@@ -1,4 +1,19 @@
-const multer = require('multer');
+// `multer` is an optional peer dep — lazy-loaded so projects that
+// don't handle multipart uploads don't have to install it.
+let _multer = null;
+function loadMulter() {
+  if (_multer) return _multer;
+  try { _multer = require('multer'); return _multer; }
+  catch (e) {
+    var err = new Error(
+      "@xeplr/utils/lib/fileUploader: 'multer' is not installed. Run `npm install multer` " +
+      "in your project. It's an optional peer dependency — only required if you handle file uploads."
+    );
+    err.cause = e;
+    throw err;
+  }
+}
+
 const path = require('path');
 const fs = require('fs');
 const { generateId } = require('./helpers');
@@ -21,6 +36,7 @@ class FileUploader {
       fs.mkdirSync(this._destination, { recursive: true });
     }
 
+    var multer = loadMulter();
     this._multer = multer({
       storage: multer.diskStorage({
         destination: (req, file, cb) => {

package/lib/otp.js

@@ -0,0 +1,111 @@
+/**
+ * OTP (one-time password) — generate, deliver, and verify short-lived codes.
+ * Delivery goes through THIS package's own sms module (see lib/sms.js: register
+ * a provider there, then otp.js sends through it) — no separate provider
+ * registration here, one registry to keep in sync.
+ *
+ * Codes live in Redis (lib/cache.js) — no DB table, no cleanup job. Expiry is
+ * just the Redis key's TTL.
+ *
+ * Usage:
+ *   var otp = require('@xeplr/utils').otp;
+ *   otp.configureOtp({ provider: 'twilio' });   // optional — see defaults below
+ *
+ *   await otp.requestOtp('+91...');              // generates + sends a code
+ *   await otp.verifyOtp('+91...', '482913');     // { success: true } or { success:false, reason }
+ */
+const crypto = require('crypto');
+const cache = require('./cache');
+const sms = require('./sms');
+
+var _config = {
+  codeLength: 6,
+  ttlSeconds: 300,     // 5 minutes
+  maxAttempts: 5,
+  keyPrefix: 'otp:',
+  provider: null,       // sms provider name (see lib/sms.js register()); falls back to sms.setDefault()
+  message: function(code) { return 'Your verification code is ' + code; }
+};
+
+/**
+ * Configure OTP policy. All optional — defaults above apply otherwise.
+ * @param {object} config
+ * @param {number} [config.codeLength=6]
+ * @param {number} [config.ttlSeconds=300]
+ * @param {number} [config.maxAttempts=5]
+ * @param {string} [config.provider] - sms provider name registered via sms.register()
+ * @param {function} [config.message] - (code) => string, the SMS body
+ */
+function configureOtp(config) {
+  Object.assign(_config, config || {});
+}
+
+function generateCode() {
+  var max = Math.pow(10, _config.codeLength);
+  var code = crypto.randomInt(0, max);
+  return String(code).padStart(_config.codeLength, '0');
+}
+
+function otpKey(identifier) {
+  return _config.keyPrefix + identifier;
+}
+
+/**
+ * Generate a code, store it, and send it via the configured SMS provider.
+ * @param {string} identifier - phone number (or any unique key) the code is tied to
+ * @returns {Promise<{ sent: boolean }>}
+ */
+async function requestOtp(identifier) {
+  var code = generateCode();
+  await cache.set(otpKey(identifier), { code: code, attempts: 0 }, _config.ttlSeconds);
+
+  var message = _config.message(code);
+  var result = _config.provider
+    ? await sms.send(_config.provider, { to: identifier, message: message })
+    : await sms.send({ to: identifier, message: message });
+
+  if (!result.success) {
+    await cache.del(otpKey(identifier));
+    throw new Error('Failed to send OTP: ' + (result.error || 'unknown error'));
+  }
+  return { sent: true };
+}
+
+/**
+ * Verify a submitted code against the stored one. Single-use — deleted on
+ * success. maxAttempts is the real security bound (not TTL precision): a
+ * wrong guess re-arms the same TTL window rather than tracking remaining
+ * time, so repeated wrong guesses can extend the window, but never the
+ * attempt count past maxAttempts.
+ * @param {string} identifier
+ * @param {string} code
+ * @returns {Promise<{ success: boolean, reason?: 'expired'|'invalid'|'too_many_attempts' }>}
+ */
+async function verifyOtp(identifier, code) {
+  var key = otpKey(identifier);
+  var record = await cache.get(key);
+
+  if (!record) {
+    return { success: false, reason: 'expired' };
+  }
+
+  if (record.attempts >= _config.maxAttempts) {
+    await cache.del(key);
+    return { success: false, reason: 'too_many_attempts' };
+  }
+
+  if (String(code) !== record.code) {
+    record.attempts += 1;
+    if (record.attempts >= _config.maxAttempts) {
+      await cache.del(key);
+      return { success: false, reason: 'too_many_attempts' };
+    }
+    await cache.set(key, record, _config.ttlSeconds);
+    return { success: false, reason: 'invalid' };
+  }
+
+  await cache.del(key);
+  return { success: true };
+}
+
+module.exports = { configureOtp, requestOtp, verifyOtp };

package/lib/queue.js

@@ -157,4 +157,445 @@ class Queue {
   }
 }
 
+var { classifySqlError } = require('./sql-error');
+
+// ─────────────────────────────────────────────────────────────────────────
+// SqlQueue — in-memory concurrent worker pool for SQL execution.
+//
+// Movement-scoped: every item carries a `movementId`. Rollback is by
+// movementId. Aborting drops all queued items for one movement without
+// affecting others.
+//
+// Retry / bisect / drop / abort behavior:
+//   - Up to `maxAttempts` per item (default 3); errorExecutor decides
+//     what to do on each failure ('retry' | 'bisect' | 'error-table' |
+//     'drop' | 'fatal').
+//   - 'bisect' splits `item.meta.rows` in half, regenerates two child
+//     SQL statements via `item.meta.rowsToSql(rows)`, and re-enqueues both.
+//   - 'error-table' calls `onErrorTable({item, error, rowNum})` and counts
+//     as a drop.
+//   - `maxConsecutiveDrops` (default 5) drops within the same movement
+//     → auto-abort that movement.
+//   - 'fatal' → auto-abort that movement immediately.
+//
+// Backpressure: total serialized item bytes ≤ `maxMemoryMB * 1024 * 1024`
+// (default 200MB high water). `addToQueue` returns a promise that awaits
+// when over the ceiling, resumes at 75% low water.
+//
+// Encrypted connections: `connections: { name: encryptedString | plainConfig }`
+// + `encryptionKey`. String values are decrypted via
+// `@xeplr/utils/isomorphic/crypto` on first use and cached.
+class SqlQueue {
+  constructor(options) {
+    options = options || {};
+    if (typeof options.executor !== 'function') {
+      throw new Error('SqlQueue: options.executor is required (async (item, resolvedConn) => void)');
+    }
+    this.executor           = options.executor;
+    this.errorExecutor      = options.errorExecutor      || defaultErrorExecutor;
+    this.onErrorTable       = options.onErrorTable       || function() {};
+    this.onMovementAbort    = options.onMovementAbort    || function() {};
+    this.concurrency        = options.concurrency        || 4;
+    this.maxAttempts        = options.maxAttempts        || 3;
+    this.maxConsecutiveDrops= options.maxConsecutiveDrops|| 5;
+    this.maxMemoryBytes     = (options.maxMemoryMB       || 200) * 1024 * 1024;
+    this.lowMemoryBytes     = Math.floor(this.maxMemoryBytes * 0.75);
+    this.retryDelaysMs      = options.retryDelaysMs      || [5000, 15000, 45000];
+    this.connections        = options.connections        || {};
+    this.encryptionKey      = options.encryptionKey      || null;
+
+    this._items       = [];
+    this._itemId      = 0;
+    this._byteTotal   = 0;
+    this._inFlight    = 0;
+    this._pendingRetries = 0;               // items awaiting their retry setTimeout
+    this._stopped     = false;
+    this._paused      = false;
+    this._pressureWaiters = [];
+    this._idleWaiters = [];
+    this._resolved    = {};                 // decrypted connection cache
+    this._movements   = new Map();          // movementId → state
+
+    this._workers = [];
+    for (var i = 0; i < this.concurrency; i++) {
+      this._workers.push(this._workerLoop());
+    }
+  }
+
+  // Enqueue an item. Awaits when the queue is over its memory ceiling.
+  // Item shape:
+  //   { movementId, connection, sql?, meta: { rows?, rowsToSql?, errorTable?, ... }, attempt? }
+  // `sql` is generated from `meta.rowsToSql(meta.rows)` if not supplied.
+  async addToQueue(item) {
+    if (this._stopped) throw new Error('SqlQueue is stopped');
+    if (!item || !item.movementId) throw new Error('addToQueue: item.movementId is required');
+    if (!item.sql && item.meta && typeof item.meta.rowsToSql === 'function' && Array.isArray(item.meta.rows)) {
+      var builtA = item.meta.rowsToSql(item.meta.rows);
+      if (typeof builtA === 'string') { item.sql = builtA; }
+      else if (builtA && builtA.sql)  { item.sql = builtA.sql; if (builtA.params != null) item.params = builtA.params; }
+    }
+    if (!item.sql) throw new Error('addToQueue: item.sql is required (or provide meta.rowsToSql + meta.rows)');
+
+    while (this._byteTotal >= this.maxMemoryBytes) {
+      await new Promise(function(res) { this._pressureWaiters.push(res); }.bind(this));
+    }
+
+    item.id      = ++this._itemId;
+    item.attempt = item.attempt || 0;
+    item.bytes   = approximateBytes(item);
+    this._byteTotal += item.bytes;
+    this._items.push(item);
+
+    var state = this._stateFor(item.movementId);
+    state.queued++;
+  }
+
+  // Abort a movement. Drops queued items for that movement and prevents
+  // in-flight retries. Emits onMovementAbort. In-flight SQLs are allowed
+  // to settle — caller runs uploader.rollback() to clean the DB.
+  abort(movementId, reason) {
+    var state = this._stateFor(movementId);
+    if (state.aborted) return;
+    state.aborted = true;
+    state.abortReason = reason || 'aborted';
+
+    var kept = [];
+    for (var i = 0; i < this._items.length; i++) {
+      var it = this._items[i];
+      if (it.movementId === movementId) {
+        this._byteTotal -= it.bytes;
+        state.queued--;
+        state.dropped += rowsOf(it);
+        state.statementsDropped++;
+      } else {
+        kept.push(it);
+      }
+    }
+    this._items = kept;
+    this._releaseBackpressure();
+
+    try { this.onMovementAbort({ movementId: movementId, reason: state.abortReason }); }
+    catch (e) { /* swallow — never let a hook block */ }
+  }
+
+  // Drop everything queued for a movement that has already aborted.
+  //
+  // Same bookkeeping as abort()'s own sweep — these rows are lost either way,
+  // and a count that omits them is the same lie by a slower route.
+  _purgeAborted() {
+    if (!this._items.length) return;
+    var kept = [];
+    for (var i = 0; i < this._items.length; i++) {
+      var it = this._items[i];
+      var st = this._stateFor(it.movementId);
+      if (st.aborted) {
+        this._byteTotal -= it.bytes;
+        st.queued--;
+        st.dropped += rowsOf(it);
+        st.statementsDropped++;
+      } else {
+        kept.push(it);
+      }
+    }
+    if (kept.length !== this._items.length) {
+      this._items = kept;
+      this._releaseBackpressure();
+    }
+  }
+
+  // Stats: per-movement if id passed, else global.
+  stats(movementId) {
+    if (movementId) {
+      var s = this._movements.get(movementId);
+      return s ? Object.assign({}, s) : null;
+    }
+    var total = { queued: this._items.length, inFlight: this._inFlight, bytes: this._byteTotal, movements: this._movements.size };
+    return total;
+  }
+
+  // Resolve when the queue drains AND no items are in flight AND no
+  // retry is pending. Useful after a spool ends and before checking
+  // final counts.
+  async drain() {
+    while (this._items.length > 0 || this._inFlight > 0 || this._pendingRetries > 0) {
+      await new Promise(function(res) { this._idleWaiters.push(res); }.bind(this));
+    }
+  }
+
+  pause()   { this._paused = true; }
+  resume()  { if (this._paused) { this._paused = false; this._kick(); } }
+  stop()    { this._stopped = true; this._paused = true; this._releaseBackpressure(); }
+
+  // ─── internal ─────────────────────────────────────────────────────────
+  _stateFor(movementId) {
+    var s = this._movements.get(movementId);
+    if (!s) {
+      // `completed` and `dropped` count ROWS, not statements.
+      //
+      // They counted statements, and one statement is a multi-row INSERT — so a
+      // 12,000-row movement in three batches reported "completed: 3". That
+      // number is surfaced to people as ROWS LOADED (import_meta.completed, and
+      // the import history page reading it), which meant every import in the
+      // product has been reporting its batch count as a row count.
+      //
+      // Every queued item already carries meta.rowCount; the counters just were
+      // not using it. Statements are counted separately for anyone who wants
+      // them — see statements/statementsDropped.
+      s = {
+        movementId: movementId, queued: 0, inFlight: 0,
+        completed: 0, dropped: 0,
+        statements: 0, statementsDropped: 0,
+        aborted: false, abortReason: null, consecutiveDrops: 0
+      };
+      this._movements.set(movementId, s);
+    }
+    return s;
+  }
+
+  async _workerLoop() {
+    while (!this._stopped) {
+      if (this._paused || this._items.length === 0 || this._byteTotal === 0) {
+        await sleep(25);
+        this._maybeSignalIdle();
+        continue;
+      }
+      // Pick the first item whose movement isn't aborted.
+      var idx = -1;
+      for (var i = 0; i < this._items.length; i++) {
+        var m = this._items[i].movementId;
+        if (!this._stateFor(m).aborted) { idx = i; break; }
+      }
+      // NOTHING LEFT THAT IS ALLOWED TO RUN — every queued item belongs to a
+      // movement that has aborted. They can never be picked up (this loop
+      // skips aborted movements) and nothing else removes them, so without
+      // this they sit in _items forever and drain() waits on a queue that
+      // will never empty: a movement that has already finished its work and
+      // hangs, with no summary line ever written.
+      //
+      // Reachable because abort() clears what is queued AT THAT MOMENT, while
+      // items keep arriving after it — a bisect re-enqueueing children of an
+      // in-flight failure, or a still-running spool adding the next batch.
+      // Masked until deterministic errors stopped being retried: the retry
+      // backoff used to hold those children in _pendingRetries (which DOES
+      // check aborted) rather than in the queue.
+      if (idx < 0) {
+        this._purgeAborted();
+        await sleep(25);
+        this._maybeSignalIdle();
+        continue;
+      }
+
+      var item = this._items.splice(idx, 1)[0];
+      this._byteTotal -= item.bytes;
+      this._releaseBackpressure();
+
+      var state = this._stateFor(item.movementId);
+      state.queued--;
+      state.inFlight++;
+      this._inFlight++;
+
+      try { await this._processItem(item, state); }
+      catch (e) { /* processItem never throws — belt and braces */ }
+      finally { state.inFlight--; this._inFlight--; this._maybeSignalIdle(); }
+    }
+  }
+
+  async _processItem(item, state) {
+    if (state.aborted) return;
+
+    var conn;
+    try { conn = await this._resolveConnection(item.connection); }
+    catch (err) {
+      // Connection resolution failure = fatal for the movement.
+      state.dropped += rowsOf(item);
+      state.statementsDropped++;
+      this.abort(item.movementId, 'connection_resolve_failed: ' + err.message);
+      return;
+    }
+
+    item.attempt++;
+    try {
+      await this.executor(item, conn);
+      state.completed += rowsOf(item);
+      state.statements++;
+      state.consecutiveDrops = 0;
+      return;
+    } catch (err) {
+      var attemptedFinal = item.attempt >= this.maxAttempts;
+      var decision = await this.errorExecutor({ item: item, error: err, attempt: item.attempt, isFinal: attemptedFinal });
+      decision = decision || {};
+
+      if (decision.decision === 'retry' && !attemptedFinal && !state.aborted) {
+        // Delays indexed by "which retry": 1st retry uses [0], 2nd uses [1], etc.
+        var delayIdx = Math.min(item.attempt - 1, this.retryDelaysMs.length - 1);
+        var delay = decision.delayMs != null ? decision.delayMs : this.retryDelaysMs[delayIdx];
+        this._pendingRetries++;
+        setTimeout(function() {
+          this._pendingRetries--;
+          if (!state.aborted && !this._stopped) {
+            item.bytes = approximateBytes(item);
+            this._byteTotal += item.bytes;
+            this._items.push(item);
+            state.queued++;
+          }
+          this._maybeSignalIdle();
+        }.bind(this), delay);
+        return;
+      }
+
+      if (decision.decision === 'bisect' && item.meta && Array.isArray(item.meta.rows) && item.meta.rows.length > 1) {
+        // Not into an aborted movement. Splitting a batch to find out which
+        // half is bad is only worth doing if the halves can still run, and
+        // they cannot — the movement has given up. Counted as dropped,
+        // because that is what happens to them.
+        if (state.aborted) {
+          state.dropped += rowsOf(item);
+          state.statementsDropped++;
+          return;
+        }
+        var mid = Math.floor(item.meta.rows.length / 2);
+        var left = cloneItemWithRows(item, item.meta.rows.slice(0, mid));
+        var right = cloneItemWithRows(item, item.meta.rows.slice(mid));
+        await this.addToQueue(left);
+        await this.addToQueue(right);
+        return;
+      }
+
+      if (decision.decision === 'fatal') {
+        this.abort(item.movementId, 'fatal: ' + (decision.reason || err.message));
+        return;
+      }
+
+      // 'error-table' | 'drop' | anything else past max attempts → drop
+      state.dropped += rowsOf(item);
+      state.statementsDropped++;
+      state.consecutiveDrops++;
+      try {
+        this.onErrorTable({
+          item: item,
+          error: err,
+          rowNum: item.meta && item.meta.rowNum,
+          reason: decision.reason || err.message,
+          // The database's OWN identifier for what went wrong ('23502', 515,
+          // 'ER_BAD_NULL_ERROR') and whether it was ever worth retrying —
+          // facts a log analyzer can group by, where the message is prose
+          // that varies by server version and locale.
+          errorCode: decision.errorCode != null ? decision.errorCode : null,
+          errorKind: decision.errorKind || null,
+          attempts: item.attempt
+        });
+      } catch (_) { /* swallow */ }
+      if (state.consecutiveDrops >= this.maxConsecutiveDrops) {
+        this.abort(item.movementId, 'consecutive_drops_exceeded');
+      }
+    }
+  }
+
+  async _resolveConnection(name) {
+    if (this._resolved[name]) return this._resolved[name];
+    var raw = this.connections[name];
+    if (raw === undefined) throw new Error('SqlQueue: unknown connection "' + name + '"');
+    if (typeof raw === 'object') { this._resolved[name] = raw; return raw; }
+    if (typeof raw !== 'string')  throw new Error('SqlQueue: connection "' + name + '" must be encrypted string or plain object');
+    if (!this.encryptionKey)      throw new Error('SqlQueue: encryptionKey required to decrypt connection "' + name + '"');
+    var { decrypt } = require('../isomorphic/crypto');
+    var decrypted = await decrypt(raw, this.encryptionKey);
+    var config = JSON.parse(decrypted);
+    this._resolved[name] = config;
+    return config;
+  }
+
+  _releaseBackpressure() {
+    if (this._byteTotal <= this.lowMemoryBytes && this._pressureWaiters.length) {
+      var waiters = this._pressureWaiters;
+      this._pressureWaiters = [];
+      for (var i = 0; i < waiters.length; i++) waiters[i]();
+    }
+  }
+
+  _maybeSignalIdle() {
+    if (this._items.length === 0 && this._inFlight === 0 && this._pendingRetries === 0 && this._idleWaiters.length) {
+      var waiters = this._idleWaiters;
+      this._idleWaiters = [];
+      for (var i = 0; i < waiters.length; i++) waiters[i]();
+    }
+  }
+
+  _kick() { /* worker loops poll — nothing to do */ }
+}
+
+function defaultErrorExecutor(ctx) {
+  // Default: retry until final attempt, then route the row (or the whole
+  // batch if not bisectable) to the error table.
+  //
+  // EXCEPT when the database has already given its final answer. A NOT NULL
+  // violation, a failed cast or a missing column fails identically however
+  // many times it is sent, so retrying one buys nothing and costs the whole
+  // backoff — 65 seconds by default, per item, and a bisect resets its
+  // children to attempt 0 so that multiplies down the tree. Measured on a
+  // 1000-row movement into a NOT NULL column: 105 seconds, nearly all of it
+  // asleep, for a verdict available immediately.
+  //
+  // Straight to bisect instead, which is the fast path to the SAME outcome —
+  // it isolates which rows are bad instead of waiting to find out.
+  // classifySqlError treats anything it does not recognise as retryable, so
+  // this only ever skips waiting when the error is known to be deterministic.
+  var verdict = classifySqlError(ctx.error);
+  var bisectable = ctx.item.meta && Array.isArray(ctx.item.meta.rows) && ctx.item.meta.rows.length > 1;
+
+  if (!verdict.retryable) {
+    if (bisectable) return { decision: 'bisect', errorCode: verdict.code, errorKind: verdict.kind };
+    return {
+      decision: 'error-table',
+      reason: ctx.error && ctx.error.message,
+      errorCode: verdict.code,
+      errorKind: verdict.kind
+    };
+  }
+
+  if (!ctx.isFinal) return { decision: 'retry' };
+  if (bisectable) return { decision: 'bisect', errorCode: verdict.code, errorKind: verdict.kind };
+  return {
+    decision: 'error-table',
+    reason: ctx.error && ctx.error.message,
+    errorCode: verdict.code,
+    errorKind: verdict.kind
+  };
+}
+
+function cloneItemWithRows(item, rows) {
+  var clonedMeta = Object.assign({}, item.meta, { rows: rows, rowCount: rows.length });
+  var next = {
+    movementId: item.movementId,
+    connection: item.connection,
+    meta:       clonedMeta,
+    attempt:    0
+  };
+  if (typeof clonedMeta.rowsToSql === 'function') {
+    var built = clonedMeta.rowsToSql(rows);
+    if (typeof built === 'string') { next.sql = built; next.params = item.params; }
+    else if (built && built.sql)   { next.sql = built.sql; next.params = built.params; }
+  } else {
+    next.sql = item.sql; next.params = item.params;
+  }
+  return next;
+}
+
+// Rows in one queued item. The uploader puts the real count on meta; anything
+// that queues without one counts as a single row, which keeps a caller that
+// enqueues row-at-a-time honest rather than reporting zero.
+function rowsOf(item) {
+  var n = item && item.meta && item.meta.rowCount;
+  return typeof n === 'number' && n >= 0 ? n : 1;
+}
+
+function approximateBytes(item) {
+  try { return JSON.stringify(item).length; } catch (_) { return 128; }
+}
+
+function sleep(ms) { return new Promise(function(res) { setTimeout(res, ms); }); }
+
 module.exports = Queue;
+module.exports.Queue = Queue;
+module.exports.SqlQueue = SqlQueue;
+module.exports.classifySqlError = classifySqlError;

package/lib/sql-error.js

@@ -0,0 +1,208 @@
+// WHICH SQL FAILURES ARE WORTH TRYING AGAIN.
+//
+// A retry is a bet that the same statement, sent again, behaves differently.
+// That bet pays off for a dropped connection, a deadlock victim or a server
+// out of connections — and never for a NOT NULL violation, a bad cast or a
+// column that does not exist. Those fail identically every time, so retrying
+// one costs the backoff (5s + 15s + 45s by default) and then drops the rows
+// anyway.
+//
+// Measured on a real 1000-row movement into a NOT NULL column: 105 seconds,
+// almost all of it asleep, for a verdict available on the first attempt. Worse
+// than slow — a bisect restarts its children at attempt 0, so the wasted
+// backoff multiplies down the bisect tree while a person watches a movement
+// that looks hung.
+//
+// ── why one function serves postgres, mysql and mssql ────────────────────
+//
+// The three drivers throw their native error untouched (see each driver's
+// query()), and each dialect stamps its identity on a DIFFERENT property:
+//
+//   postgres   err.code    5-char SQLSTATE — '23502', '40001'
+//   mysql      err.code    ER_* name, plus err.errno — 'ER_BAD_NULL_ERROR', 1048
+//   mssql      err.number  integer — 515, 1205
+//
+// So the shapes are self-identifying and no dbType has to be threaded through
+// the queue to read them. A caller that HAS the dbType is not asked for it,
+// which keeps this usable from the queue's default error executor — the one
+// place that decides retries, and the one place with no idea what it is
+// talking to.
+//
+// ── unknown means retry ─────────────────────────────────────────────────
+//
+// An unrecognised error is treated as transient, i.e. the behavior before this
+// file existed. Wrongly retrying something deterministic costs time; wrongly
+// dropping something transient loses rows. The default belongs on the side
+// that cannot lose data.
+
+// ── postgres ────────────────────────────────────────────────────────────
+// SQLSTATE is classified by its two-character class where the whole class
+// agrees, which is most of them — listing 200 individual codes would go stale
+// against the next server release for no gain.
+//
+//   22  data exception            invalid text, numeric overflow, bad date
+//   23  integrity constraint      not null, unique, foreign key, check
+//   42  syntax error / access     no such column, no such table, no privilege
+//   3F  invalid schema name
+//   0A  feature not supported
+var PG_DETERMINISTIC_CLASSES = ['22', '23', '42', '3F', '0A'];
+//   08  connection exception      server closed the connection, failure
+//   40  transaction rollback      serialization failure, deadlock detected
+//   53  insufficient resources    too many connections, out of memory/disk
+//   57  operator intervention     shutdown, cannot connect now, admin cancel
+//   58  system error              io error
+var PG_TRANSIENT_CLASSES = ['08', '40', '53', '57', '58'];
+
+// ── mysql ───────────────────────────────────────────────────────────────
+// By errno, because err.code (the ER_ name) is absent on some client
+// versions while errno is always there. Names kept alongside for reading.
+var MYSQL_DETERMINISTIC = {
+  1048: 'ER_BAD_NULL_ERROR',          // column cannot be null
+  1062: 'ER_DUP_ENTRY',               // duplicate key
+  1064: 'ER_PARSE_ERROR',
+  1136: 'ER_WRONG_VALUE_COUNT_ON_ROW',
+  1146: 'ER_NO_SUCH_TABLE',
+  1054: 'ER_BAD_FIELD_ERROR',         // unknown column
+  1264: 'ER_WARN_DATA_OUT_OF_RANGE',
+  1265: 'WARN_DATA_TRUNCATED',
+  1292: 'ER_TRUNCATED_WRONG_VALUE',   // bad date / bad cast
+  1366: 'ER_TRUNCATED_WRONG_VALUE_FOR_FIELD',
+  1406: 'ER_DATA_TOO_LONG',
+  1451: 'ER_ROW_IS_REFERENCED_2',
+  1452: 'ER_NO_REFERENCED_ROW_2',     // foreign key
+  3819: 'ER_CHECK_CONSTRAINT_VIOLATED',
+  1364: 'ER_NO_DEFAULT_FOR_FIELD',
+  1305: 'ER_SP_DOES_NOT_EXIST'
+};
+var MYSQL_TRANSIENT = {
+  1040: 'ER_CON_COUNT_ERROR',         // too many connections
+  1203: 'ER_TOO_MANY_USER_CONNECTIONS',
+  1205: 'ER_LOCK_WAIT_TIMEOUT',
+  1213: 'ER_LOCK_DEADLOCK',
+  1290: 'ER_OPTION_PREVENTS_STATEMENT', // read-only, usually a failover
+  1053: 'ER_SERVER_SHUTDOWN',
+  2002: 'CONNECTION_REFUSED',
+  2003: 'CANT_CONNECT',
+  2006: 'SERVER_GONE_AWAY',
+  2013: 'LOST_CONNECTION'
+};
+// Client-side codes carry no errno at all — a socket that died before the
+// server ever answered.
+var MYSQL_TRANSIENT_CODES = [
+  'PROTOCOL_CONNECTION_LOST', 'PROTOCOL_SEQUENCE_TIMEOUT', 'PROTOCOL_ENQUEUE_AFTER_QUIT',
+  'POOL_CLOSED', 'POOL_CONNLIMIT'
+];
+
+// ── mssql ───────────────────────────────────────────────────────────────
+var MSSQL_DETERMINISTIC = {
+  515:  'cannot insert NULL',
+  547:  'foreign key / check constraint',
+  2601: 'duplicate key in unique index',
+  2627: 'unique constraint violation',
+  245:  'conversion failed',
+  8114: 'error converting data type',
+  8152: 'string or binary data would be truncated',
+  2628: 'string or binary data would be truncated (verbose)',
+  207:  'invalid column name',
+  208:  'invalid object name',
+  102:  'incorrect syntax',
+  220:  'arithmetic overflow',
+  232:  'arithmetic overflow for type',
+  8115: 'arithmetic overflow converting'
+};
+var MSSQL_TRANSIENT = {
+  1205:  'deadlock victim',
+  1222:  'lock request timeout',
+  3960:  'snapshot isolation update conflict',
+  4060:  'cannot open database',
+  40197: 'azure: service error, request processing',
+  40501: 'azure: service busy',
+  40613: 'azure: database unavailable',
+  49918: 'azure: cannot process request, not enough resources',
+  49919: 'azure: cannot process create or update request',
+  49920: 'azure: cannot process request, too many operations',
+  10053: 'transport-level error',
+  10054: 'connection reset by peer',
+  10060: 'connection timeout',
+  233:   'no process on the other end of the pipe',
+  64:    'transport-level error on receive'
+};
+
+// Node's own socket-level failures, dialect-independent: the driver never got
+// far enough for the server to have an opinion.
+var NODE_TRANSIENT_CODES = [
+  'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ESOCKET', 'ESOCKETTIMEOUT',
+  'EPIPE', 'EHOSTUNREACH', 'ENETUNREACH', 'ENOTFOUND', 'EAI_AGAIN',
+  'ECONNCLOSED', 'ETIMEOUT', 'ENOTOPEN'
+];
+
+/**
+ * Classify one database error.
+ *
+ * @returns {{ retryable: boolean, kind: string, code: string|null, dialect: string|null }}
+ *   kind is 'transient' | 'deterministic' | 'unknown'. `code` is whatever the
+ *   dialect stamped on it, as a string, so a log line can carry the database's
+ *   own identifier rather than a paraphrase of it.
+ */
+function classifySqlError(err) {
+  var unknown = { retryable: true, kind: 'unknown', code: null, dialect: null };
+  if (!err) return unknown;
+
+  var code = err.code != null ? String(err.code) : null;
+
+  // Socket-level, before any dialect has spoken.
+  if (code && NODE_TRANSIENT_CODES.indexOf(code) !== -1) {
+    return { retryable: true, kind: 'transient', code: code, dialect: null };
+  }
+
+  // postgres — SQLSTATE: exactly five characters, digits and capitals.
+  if (code && /^[0-9A-Z]{5}$/.test(code)) {
+    var cls = code.slice(0, 2);
+    if (PG_DETERMINISTIC_CLASSES.indexOf(cls) !== -1) {
+      return { retryable: false, kind: 'deterministic', code: code, dialect: 'postgres' };
+    }
+    if (PG_TRANSIENT_CLASSES.indexOf(cls) !== -1) {
+      return { retryable: true, kind: 'transient', code: code, dialect: 'postgres' };
+    }
+    return { retryable: true, kind: 'unknown', code: code, dialect: 'postgres' };
+  }
+
+  // mysql — errno is the reliable half; the ER_ name is not always present.
+  var errno = typeof err.errno === 'number' ? err.errno : null;
+  if (errno != null && (MYSQL_DETERMINISTIC[errno] || MYSQL_TRANSIENT[errno])) {
+    var mysqlCode = code || MYSQL_DETERMINISTIC[errno] || MYSQL_TRANSIENT[errno];
+    return MYSQL_DETERMINISTIC[errno]
+      ? { retryable: false, kind: 'deterministic', code: mysqlCode, dialect: 'mysql' }
+      : { retryable: true,  kind: 'transient',     code: mysqlCode, dialect: 'mysql' };
+  }
+  if (code && MYSQL_TRANSIENT_CODES.indexOf(code) !== -1) {
+    return { retryable: true, kind: 'transient', code: code, dialect: 'mysql' };
+  }
+  // An ER_-named error with an errno this file has never heard of is still
+  // mysql, and still unknown — reported as such rather than guessed at.
+  if (code && /^ER_/.test(code)) {
+    return { retryable: true, kind: 'unknown', code: code, dialect: 'mysql' };
+  }
+
+  // mssql — tedious puts the server's error number on `number`.
+  var number = typeof err.number === 'number' ? err.number : null;
+  if (number != null) {
+    if (MSSQL_DETERMINISTIC[number]) {
+      return { retryable: false, kind: 'deterministic', code: String(number), dialect: 'mssql' };
+    }
+    if (MSSQL_TRANSIENT[number]) {
+      return { retryable: true, kind: 'transient', code: String(number), dialect: 'mssql' };
+    }
+    return { retryable: true, kind: 'unknown', code: String(number), dialect: 'mssql' };
+  }
+
+  return code ? { retryable: true, kind: 'unknown', code: code, dialect: null } : unknown;
+}
+
+/** True only when trying the identical statement again could plausibly work. */
+function isRetryableSqlError(err) { return classifySqlError(err).retryable; }
+
+module.exports = {
+  classifySqlError: classifySqlError,
+  isRetryableSqlError: isRetryableSqlError
+};

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@xeplr/utils",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Utility functions: email (SMTP, AWS SES, Azure, Brevo), cache, queue, logging client, and helpers",
   "main": "index.js",
-  "files": ["index.js", "lib/", "isomorphic/"],
+  "files": [
+    "index.js",
+    "lib/",
+    "isomorphic/"
+  ],
   "exports": {
     ".": "./index.js",
     "./isomorphic": "./isomorphic/index.js",
@@ -15,26 +19,55 @@
     "./lib/fileUploader": "./lib/fileUploader.js",
     "./lib/helpers": "./lib/helpers.js",
     "./lib/logger": "./lib/logger.js",
+    "./lib/otp": "./lib/otp.js",
     "./lib/queue": "./lib/queue.js",
     "./lib/rateLimiter": "./lib/rateLimiter.js",
-    "./lib/response": "./lib/response.js"
+    "./lib/response": "./lib/response.js",
+    "./lib/sms": "./lib/sms.js"
   },
-  "keywords": ["email", "brevo", "ses", "smtp", "cache", "redis", "queue", "logger", "utilities"],
+  "keywords": [
+    "email",
+    "brevo",
+    "ses",
+    "smtp",
+    "cache",
+    "redis",
+    "queue",
+    "logger",
+    "utilities"
+  ],
   "author": "xeplr",
   "license": "MIT",
-  "repository": { "type": "git", "url": "https://github.com/Xeplr/xeplr-utils" },
-  "publishConfig": { "access": "public" },
-  "dependencies": {
-    "ioredis": "^5.6.1",
-    "multer": "^1.4.5-lts.1",
-    "nodemailer": "^8.0.2"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Xeplr/xeplr-utils"
+  },
+  "publishConfig": {
+    "access": "public"
   },
+  "dependencies": {},
   "peerDependencies": {
     "@aws-sdk/client-ses": "^3.0.0",
-    "@azure/communication-email": "^1.0.0"
+    "@azure/communication-email": "^1.0.0",
+    "ioredis": "^5.6.1",
+    "multer": "^1.4.5-lts.1",
+    "nodemailer": "^8.0.2"
   },
   "peerDependenciesMeta": {
-    "@aws-sdk/client-ses": { "optional": true },
-    "@azure/communication-email": { "optional": true }
+    "@aws-sdk/client-ses": {
+      "optional": true
+    },
+    "@azure/communication-email": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "multer": {
+      "optional": true
+    },
+    "nodemailer": {
+      "optional": true
+    }
   }
 }