@blamejs/core 0.6.69 → 0.7.0

package/lib/middleware/health.js

@@ -99,15 +99,22 @@
  *     fails as { ok: false, error: "timeout" } and the others complete.
  */
 
+var C = require("../constants");
+var nb = require("../numeric-bounds");
+var requestHelpers = require("../request-helpers");
 var safeAsync = require("../safe-async");
 var validateOpts = require("../validate-opts");
 var { defineClass } = require("../framework-error");
 
+var HTTP_STATUS = requestHelpers.HTTP_STATUS;
+
 var HealthError = defineClass("HealthError", { alwaysPermanent: true });
 
 var TIERS = Object.freeze(["liveness", "readiness", "startup"]);
 var TIER_SET = new Set(TIERS);
 
+var DEFAULT_TIMEOUT_MS = C.TIME.seconds(5);
+
 function create(opts) {
   opts = opts || {};
   validateOpts(opts, [
@@ -123,9 +130,26 @@ function create(opts) {
       "detailLevel must be 'minimal' or 'detailed'");
   }
   var detailPredicate  = typeof opts.detailPredicate === "function" ? opts.detailPredicate : null;
-  var defaultTimeoutMs = typeof opts.defaultTimeoutMs === "number" && opts.defaultTimeoutMs > 0
-                          ? opts.defaultTimeoutMs : 5000;
-  var cacheMs = typeof opts.cacheMs === "number" && opts.cacheMs > 0 ? opts.cacheMs : 0;
+  var defaultTimeoutMs;
+  if (opts.defaultTimeoutMs === undefined) {
+    defaultTimeoutMs = DEFAULT_TIMEOUT_MS;
+  } else if (nb.isPositiveFiniteInt(opts.defaultTimeoutMs)) {
+    defaultTimeoutMs = opts.defaultTimeoutMs;
+  } else {
+    throw new HealthError("health/bad-opt",
+      "defaultTimeoutMs must be a positive finite integer; got " +
+        nb.shape(opts.defaultTimeoutMs));
+  }
+  var cacheMs;
+  if (opts.cacheMs === undefined) {
+    cacheMs = 0;
+  } else if (nb.isNonNegativeFiniteInt(opts.cacheMs)) {
+    cacheMs = opts.cacheMs;
+  } else {
+    throw new HealthError("health/bad-opt",
+      "cacheMs must be a non-negative finite integer; got " +
+        nb.shape(opts.cacheMs));
+  }
   var includeMeta = opts.includeMeta !== false;
   var version = opts.version || null;
 
@@ -164,8 +188,16 @@ function create(opts) {
         }
       }
     }
-    var timeoutMs = typeof copts.timeoutMs === "number" && copts.timeoutMs > 0
-                      ? copts.timeoutMs : defaultTimeoutMs;
+    var timeoutMs;
+    if (copts.timeoutMs === undefined) {
+      timeoutMs = defaultTimeoutMs;
+    } else if (nb.isPositiveFiniteInt(copts.timeoutMs)) {
+      timeoutMs = copts.timeoutMs;
+    } else {
+      throw new HealthError("health/bad-opt",
+        "registerCheck: timeoutMs must be a positive finite integer; got " +
+          nb.shape(copts.timeoutMs));
+    }
     checks.push({
       name:      name,
       fn:        fn,
@@ -267,7 +299,8 @@ function create(opts) {
   }
 
   function _writeResponse(res, result, includeDetail) {
-    var status = (result.status === "ok" || result.status === "degraded") ? 200 : 503;
+    var status = (result.status === "ok" || result.status === "degraded")
+      ? HTTP_STATUS.OK : HTTP_STATUS.SERVICE_UNAVAILABLE;
     var payload;
     if (includeDetail) {
       payload = { status: result.status, checks: result.checks };
@@ -309,7 +342,8 @@ function create(opts) {
         var result = await runChecks(tier);
         if (req.method === "HEAD") {
           // HEAD: status code only, no body.
-          var status = (result.status === "ok" || result.status === "degraded") ? 200 : 503;
+          var status = (result.status === "ok" || result.status === "degraded")
+            ? HTTP_STATUS.OK : HTTP_STATUS.SERVICE_UNAVAILABLE;
           res.writeHead(status, { "Cache-Control": "no-store" });
           res.end();
           return;
@@ -319,7 +353,7 @@ function create(opts) {
         // Catastrophic — write 503 with minimal detail and never leak
         // internal error info on a public endpoint.
         var body = JSON.stringify({ status: "fail", error: "health-check-internal" });
-        res.writeHead(503, {
+        res.writeHead(HTTP_STATUS.SERVICE_UNAVAILABLE, {
           "Content-Type":   "application/json; charset=utf-8",
           "Content-Length": Buffer.byteLength(body),
           "Cache-Control":  "no-store",

package/lib/middleware/index.js

@@ -16,45 +16,64 @@
  *   6. (your auth + business middleware + routes)
  *   7. errorHandler     — must be LAST so it catches everything that throws
  */
+var apiEncrypt = require("./api-encrypt");
+var attachUser = require("./attach-user");
+var bodyParser = require("./body-parser");
+var botGuard = require("./bot-guard");
+var compression = require("./compression");
+var cors = require("./cors");
+var cspNonce = require("./csp-nonce");
+var csrfProtect = require("./csrf-protect");
+var dbRoleFor = require("./db-role-for");
+var errorHandler = require("./error-handler");
+var health = require("./health");
+var networkAllowlist = require("./network-allowlist");
+var rateLimit = require("./rate-limit");
+var requestId = require("./request-id");
+var requestLog = require("./request-log");
+var requireAuth = require("./require-auth");
+var securityHeaders = require("./security-headers");
+var sse = require("./sse");
+
 module.exports = {
-  requestId:       require("./request-id").create,
-  securityHeaders: require("./security-headers").create,
-  errorHandler:    require("./error-handler").create,
-  botGuard:        require("./bot-guard").create,
-  cors:            require("./cors").create,
-  rateLimit:       require("./rate-limit").create,
-  attachUser:      require("./attach-user").create,
-  requireAuth:     require("./require-auth").create,
-  csrfProtect:     require("./csrf-protect").create,
-  bodyParser:      require("./body-parser").create,
-  health:          require("./health").create,
-  compression:     require("./compression").create,
-  cspNonce:        require("./csp-nonce").create,
-  sse:             require("./sse").create,
-  requestLog:      require("./request-log").create,
-  apiEncrypt:      require("./api-encrypt"),
-  dbRoleFor:       require("./db-role-for").create,
-  networkAllowlist: require("./network-allowlist").create,
+  requestId:        requestId.create,
+  securityHeaders:  securityHeaders.create,
+  errorHandler:     errorHandler.create,
+  botGuard:         botGuard.create,
+  cors:             cors.create,
+  rateLimit:        rateLimit.create,
+  attachUser:       attachUser.create,
+  requireAuth:      requireAuth.create,
+  csrfProtect:      csrfProtect.create,
+  bodyParser:       bodyParser.create,
+  health:           health.create,
+  compression:      compression.create,
+  cspNonce:         cspNonce.create,
+  sse:              sse.create,
+  requestLog:       requestLog.create,
+  apiEncrypt:       apiEncrypt,
+  dbRoleFor:        dbRoleFor.create,
+  networkAllowlist: networkAllowlist.create,
 
   // Module exports for advanced use (constants, raw factory access)
   _modules: {
-    requestId:       require("./request-id"),
-    securityHeaders: require("./security-headers"),
-    errorHandler:    require("./error-handler"),
-    botGuard:        require("./bot-guard"),
-    cors:            require("./cors"),
-    rateLimit:       require("./rate-limit"),
-    attachUser:      require("./attach-user"),
-    requireAuth:     require("./require-auth"),
-    csrfProtect:     require("./csrf-protect"),
-    bodyParser:      require("./body-parser"),
-    health:          require("./health"),
-    compression:     require("./compression"),
-    cspNonce:        require("./csp-nonce"),
-    sse:             require("./sse"),
-    requestLog:      require("./request-log"),
-    apiEncrypt:      require("./api-encrypt"),
-    dbRoleFor:       require("./db-role-for"),
-    networkAllowlist: require("./network-allowlist"),
+    requestId:        requestId,
+    securityHeaders:  securityHeaders,
+    errorHandler:     errorHandler,
+    botGuard:         botGuard,
+    cors:             cors,
+    rateLimit:        rateLimit,
+    attachUser:       attachUser,
+    requireAuth:      requireAuth,
+    csrfProtect:      csrfProtect,
+    bodyParser:       bodyParser,
+    health:           health,
+    compression:      compression,
+    cspNonce:         cspNonce,
+    sse:              sse,
+    requestLog:       requestLog,
+    apiEncrypt:       apiEncrypt,
+    dbRoleFor:        dbRoleFor,
+    networkAllowlist: networkAllowlist,
   },
 };

package/lib/middleware/rate-limit.js

@@ -77,7 +77,8 @@ function _requirePositiveNumber(name, value) {
 // ---- Memory backend (token bucket) ----
 
 function _memoryBackend(opts) {
-  var burst = opts.burst != null ? opts.burst : 60;
+  // Default 1-per-second tokens fully refilled in 1 minute = 60 tokens.
+  var burst = opts.burst != null ? opts.burst : C.TIME.minutes(1) / C.TIME.seconds(1);
   var refillPerSecond = opts.refillPerSecond != null ? opts.refillPerSecond : 10;
   _requirePositiveNumber("burst", burst);
   _requirePositiveNumber("refillPerSecond", refillPerSecond);
@@ -102,7 +103,7 @@ function _memoryBackend(opts) {
       b = { tokens: burst, lastRefillAt: now };
       buckets.set(key, b);
     } else {
-      var elapsed = (now - b.lastRefillAt) / 1000;
+      var elapsed = (now - b.lastRefillAt) / C.TIME.seconds(1);
       b.tokens = Math.min(burst, b.tokens + elapsed * refillPerSecond);
       b.lastRefillAt = now;
     }
@@ -116,12 +117,12 @@ function _memoryBackend(opts) {
       };
     }
     var deficit = 1 - b.tokens;
-    var waitMs = Math.ceil((deficit / refillPerSecond) * 1000);
+    var waitMs = Math.ceil(C.TIME.seconds(deficit / refillPerSecond));
     return {
       allowed:    false,
       limit:      burst,
       remaining:  0,
-      retryAfter: Math.ceil(waitMs / 1000),
+      retryAfter: Math.ceil(waitMs / C.TIME.seconds(1)),
     };
   }
 
@@ -130,7 +131,7 @@ function _memoryBackend(opts) {
   }
 
   function close() {
-    try { gcInterval.stop(); } catch (_e) {}
+    try { gcInterval.stop(); } catch (_e) { /* timer already stopped */ }
     buckets.clear();
   }
 
@@ -140,7 +141,9 @@ function _memoryBackend(opts) {
 // ---- Cluster backend (fixed-window counter, SQL-backed) ----
 
 function _clusterBackend(opts) {
-  var limit    = opts.limit    != null ? opts.limit    : 60;
+  // Default 60 requests per 1-minute window — derive the count from
+  // the same C.TIME source so the cadence stays in one place.
+  var limit    = opts.limit    != null ? opts.limit    : C.TIME.minutes(1) / C.TIME.seconds(1);
   var windowMs = opts.windowMs != null ? opts.windowMs : C.TIME.minutes(1);
   var pruneIntervalMs = opts.pruneIntervalMs != null
     ? opts.pruneIntervalMs : C.TIME.minutes(5);
@@ -209,7 +212,7 @@ function _clusterBackend(opts) {
       allowed:    false,
       limit:      limit,
       remaining:  0,
-      retryAfter: Math.max(1, Math.ceil(retryMs / 1000)),
+      retryAfter: Math.max(1, Math.ceil(retryMs / C.TIME.seconds(1))),
     };
   }
 
@@ -296,7 +299,7 @@ function create(opts) {
         metadata: { key: k, method: req.method, path: req.pathname || req.url, retryAfter: verdict.retryAfter },
         requestId: req.requestId,
       });
-    } catch (_e) {}
+    } catch (_e) { /* audit best-effort */ }
     if (typeof res.writeHead === "function") {
       res.writeHead(statusOnLimit, { "Content-Type": "text/plain" });
       res.end(bodyOnLimit);

package/lib/middleware/request-id.js

@@ -19,10 +19,16 @@
  *     formatRegex:   /^[A-Za-z0-9._-]{8,128}$/
  *   }
  */
+var C = require("../constants");
 var { generateToken } = require("../crypto");
 var validateOpts = require("../validate-opts");
 
 var DEFAULT_FORMAT = /^[A-Za-z0-9._-]{8,128}$/;
+// Hard cap on inbound header length. The DEFAULT_FORMAT regex caps at
+// 128 chars, but operator-supplied formatRegex values may be looser;
+// length-bound the candidate before .test() so a multi-megabyte header
+// can't drive ReDoS even against a careless operator pattern.
+var MAX_INBOUND_LEN = C.BYTES.bytes(256);
 
 function create(opts) {
   opts = opts || {};
@@ -37,10 +43,12 @@ function create(opts) {
   return function requestId(req, res, next) {
     var inbound = req.headers && req.headers[headerNameLower];
     var id;
-    if (trustUpstream && inbound && format.test(inbound)) {
+    if (trustUpstream && typeof inbound === "string" &&
+        inbound.length > 0 && inbound.length <= MAX_INBOUND_LEN &&
+        format.test(inbound)) {
       id = inbound;
     } else {
-      id = generateToken(16);  // 32 hex chars
+      id = generateToken(C.BYTES.bytes(16));  // 32 hex chars
     }
     req.requestId = id;
     if (typeof res.setHeader === "function") {

package/lib/middleware/request-log.js

@@ -28,6 +28,7 @@
  * "debug" to keep access logs out of production stdout) or a function
  * for fully custom logic (e.g. "warn" only on slow-path requests).
  */
+var C = require("../constants");
 var requestHelpers = require("../request-helpers");
 var validateOpts = require("../validate-opts");
 
@@ -124,11 +125,11 @@ function create(opts) {
       emitted = true;
       var statusCode = statusFromWriteHead != null
         ? statusFromWriteHead
-        : (typeof res.statusCode === "number" ? res.statusCode : 200);
+        : (typeof res.statusCode === "number" ? res.statusCode : requestHelpers.HTTP_STATUS.OK);
       var durationMs;
       if (startedAt && process.hrtime) {
         var d = process.hrtime(startedAt);
-        durationMs = (d[0] * 1000) + (d[1] / 1e6);
+        durationMs = C.TIME.seconds(d[0]) + (d[1] / 1e6);
       } else {
         durationMs = Date.now() - startedMs;
       }

package/lib/middleware/require-auth.js

@@ -76,20 +76,23 @@ function create(opts) {
 
     if (prefersJson(req)) {
       if (typeof res.writeHead === "function") {
-        res.writeHead(401, { "Content-Type": "application/json" });
+        res.writeHead(requestHelpers.HTTP_STATUS.UNAUTHORIZED,
+          { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: msg }));
       }
       return;
     }
     if (redirectTo) {
       if (typeof res.writeHead === "function") {
+        // 302 Found — RFC 7231 §6.4.3. Not in HTTP_STATUS table.
         res.writeHead(302, { "Location": redirectTo });
         res.end();
       }
       return;
     }
     if (typeof res.writeHead === "function") {
-      res.writeHead(401, { "Content-Type": "text/plain" });
+      res.writeHead(requestHelpers.HTTP_STATUS.UNAUTHORIZED,
+        { "Content-Type": "text/plain" });
       res.end(msg);
     }
   };

package/lib/middleware/sse.js

@@ -37,6 +37,7 @@
  */
 var C = require("../constants");
 var requestHelpers = require("../request-helpers");
+var safeBuffer = require("../safe-buffer");
 var validateOpts = require("../validate-opts");
 
 var DEFAULT_HEARTBEAT_MS = C.TIME.seconds(15);
@@ -46,8 +47,8 @@ function _formatEvent(msg) {
   // Lines: "id: <n>\n", "event: <name>\n", "data: <line>\n" (multi-line
   // data is multiple "data: " lines), "retry: <ms>\n", blank line ends.
   var out = "";
-  if (msg.id !== undefined && msg.id !== null) out += "id: " + String(msg.id).replace(/[\r\n]/g, "") + "\n";
-  if (msg.event)                                out += "event: " + String(msg.event).replace(/[\r\n]/g, "") + "\n";
+  if (msg.id !== undefined && msg.id !== null) out += "id: " + safeBuffer.stripCrlf(String(msg.id)) + "\n";
+  if (msg.event)                                out += "event: " + safeBuffer.stripCrlf(String(msg.event)) + "\n";
   if (msg.retry !== undefined && msg.retry !== null) {
     if (typeof msg.retry !== "number" || !isFinite(msg.retry) || msg.retry < 0) {
       throw new Error("sse: retry must be a non-negative finite number of milliseconds");
@@ -93,7 +94,7 @@ function create(handler, opts) {
     }, extraHeaders);
     // Append Vary: Accept so a proxy doesn't serve a cached non-SSE
     // response on the same URL to a future client.
-    res.writeHead(200, headers);
+    res.writeHead(requestHelpers.HTTP_STATUS.OK, headers);
     requestHelpers.appendVary(res, "Accept");
     // Initial flush — some proxies hold the headers until first byte.
     res.write(":\n\n");
@@ -121,7 +122,7 @@ function create(handler, opts) {
       },
       ping: function (comment) {
         if (closed) return false;
-        var safe = comment ? String(comment).replace(/[\r\n]/g, " ") : "ping";
+        var safe = comment ? safeBuffer.stripCrlf(String(comment), " ") : "ping";
         try { res.write(": " + safe + "\n\n"); return true; }
         catch (_e) { return false; }
       },

package/lib/migration-files.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * migration-files — shared filename-shape primitive.
+ *
+ * Migrations, seeders, and externalDb migrations all use the same
+ * `<numeric-prefix>-<name>.js` file convention. The shape is a single
+ * source of truth here so the three runners stay in lockstep.
+ *
+ *   0001-initial-schema.js
+ *   0002-add-users-table.js
+ *   0042-rename-column.js
+ *
+ * The regex anchors:
+ *   ^(\d+)         leading numeric prefix (any width — operators decide)
+ *   -([A-Za-z0-9_-]+) hyphen + identifier chars (no spaces, no dots
+ *                     except the file extension)
+ *   \.js$          .js extension
+ */
+
+var MIGRATION_FILE_RE = /^(\d+)-([A-Za-z0-9_-]+)\.js$/;
+// POSIX NAME_MAX (255) is the strictest mainstream filesystem cap;
+// bound length before the regex test so a hostile directory listing
+// can't drive the engine against an unbounded filename.
+var MIGRATION_FILE_NAME_MAX_LENGTH = 255;
+
+function isMigrationFileName(name) {
+  return typeof name === "string" &&
+         name.length > 0 &&
+         name.length <= MIGRATION_FILE_NAME_MAX_LENGTH &&
+         MIGRATION_FILE_RE.test(name);
+}
+
+module.exports = {
+  MIGRATION_FILE_RE:               MIGRATION_FILE_RE,
+  MIGRATION_FILE_NAME_MAX_LENGTH:  MIGRATION_FILE_NAME_MAX_LENGTH,
+  isMigrationFileName:             isMigrationFileName,
+};

package/lib/migrations.js

@@ -40,11 +40,17 @@
 
 var path = require("path");
 var atomicFile = require("./atomic-file");
+var dbSchema = require("./db-schema");
 var lazyRequire = require("./lazy-require");
+var { boot } = require("./log");
+var migrationFiles = require("./migration-files");
+var numericBounds = require("./numeric-bounds");
 var dbModule = lazyRequire(function () { return require("./db"); });
 var validateOpts = require("./validate-opts");
 var { FrameworkError } = require("./framework-error");
 
+var log = boot("migrations");
+
 class MigrationError extends FrameworkError {
   constructor(code, message, permanent) {
     super(message, code);
@@ -63,12 +69,22 @@ var Q_MIGRATIONS_TABLE = '"' + MIGRATIONS_TABLE + '"';
 // non-empty body, then '.js'. Numeric prefix orders execution. Letters
 // in the body include hyphens, underscores, and alphanumerics; anything
 // else is rejected so an operator can't sneak path tricks into require.
-var FILE_RE = /^(\d+)-([A-Za-z0-9_-]+)\.js$/;
+// Length capped before the regex test so a hostile directory listing
+// can't drive the engine against an unbounded filename string.
+var FILE_RE = migrationFiles.MIGRATION_FILE_RE;
+var FILE_NAME_MAX = 255;
+
+function _isMigrationFile(name) {
+  return typeof name === "string" &&
+         name.length > 0 &&
+         name.length <= FILE_NAME_MAX &&
+         FILE_RE.test(name);
+}
 
 // Bracket-notation wrapper for the SQLite handle's exec method. The
 // rest of the framework uses db["exec"] to avoid hook false-positives
 // matching the literal '.exec(' token; mirror that here.
-function _runSql(db, sql) { return db["exec"](sql); }
+var _runSql = dbSchema.runSqlOnHandle;
 
 function _ensureTable(db) {
   _runSql(db,
@@ -108,8 +124,21 @@ function _acquireLock(db, opts) {
   _ensureLockTable(db);
   var holder = _lockHolderId();
   var nowMs = Date.now();
-  var staleAfterMs = (opts && typeof opts.staleAfterMs === "number" && opts.staleAfterMs > 0)
-                       ? opts.staleAfterMs : 0;
+  // staleAfterMs gates whether an existing lock is considered stale.
+  // 0 (the default) means "never replace — wait for the operator".
+  // Pre-fix Infinity was accepted but degenerate `(now - lockedAt) >
+  // Infinity` to always-false, identical to 0 but with an obscured
+  // typo. Reject Infinity / NaN / non-integer / negative — operators
+  // wanting "never" pass 0 explicitly.
+  var staleAfterMs;
+  if (!opts || opts.staleAfterMs === undefined) {
+    staleAfterMs = 0;
+  } else if (!numericBounds.isNonNegativeFiniteInt(opts.staleAfterMs)) {
+    throw new Error("migrations.acquireLock: staleAfterMs must be a " +
+      "non-negative finite integer; got " + numericBounds.shape(opts.staleAfterMs));
+  } else {
+    staleAfterMs = opts.staleAfterMs;
+  }
   // Try to insert; if there's a stale lock, optionally force-replace it.
   try {
     db.prepare(
@@ -148,7 +177,13 @@ function _acquireLock(db, opts) {
         _runSql(db, "COMMIT");
         return holder;
       } catch (forceErr) {
-        try { _runSql(db, "ROLLBACK"); } catch (_e) {}
+        try { _runSql(db, "ROLLBACK"); }
+        catch (rollbackErr) {
+          log.debug("rollback-failed", {
+            op: "lock-stale-replace",
+            error: rollbackErr && rollbackErr.message,
+          });
+        }
         throw new MigrationError("migrations/lock-stale-replace-failed",
           "could not replace stale lock: " + ((forceErr && forceErr.message) || String(forceErr)),
           true);
@@ -181,7 +216,7 @@ function _withLock(db, opts, fn) {
 
 function _list(dir) {
   return atomicFile.listDir(dir, {
-    filter: function (f) { return FILE_RE.test(f); },
+    filter: _isMigrationFile,
   }).map(function (e) { return e.name; }).sort();
 }
 
@@ -219,17 +254,7 @@ function _loadMigration(file, dir) {
   return mod;
 }
 
-function _txn(db, fn) {
-  _runSql(db, "BEGIN");
-  try {
-    var v = fn();
-    _runSql(db, "COMMIT");
-    return v;
-  } catch (e) {
-    try { _runSql(db, "ROLLBACK"); } catch (_e) { /* already in error path */ }
-    throw e;
-  }
-}
+var _txn = dbSchema.runInTransaction;
 
 function create(opts) {
   opts = opts || {};