@blamejs/core 0.4.15 → 0.4.16

package/CHANGELOG.md

@@ -8,6 +8,7 @@ upgrading across more than a few patches at a time.
 
 ## v0.4.x
 
+- **0.4.15** (2026-04-30) — b.httpClient: redirect-following + outbound multipart
 - **0.4.14** (2026-04-30) — b.i18n: lazy locales + ordinal plurals + onMissingKey hook
 - **0.4.13** (2026-04-30) — b.db: streaming query results
 - **0.4.12** (2026-04-30) — b.log: multi-sink output with per-sink level filtering

package/lib/http-client.js

@@ -375,6 +375,50 @@ function request(opts) {
     return Promise.reject(_makeError(opts && opts.errorClass, "BAD_ARG", "url is required", true));
   }
 
+  // Validate before/after shapes early — Tier-A throw if the operator
+  // passed something un-callable so the bug surfaces at the call site
+  // rather than inside the request loop.
+  if (opts.before !== undefined) {
+    if (!Array.isArray(opts.before) || !opts.before.every(function (f) { return typeof f === "function"; })) {
+      return Promise.reject(_makeError(opts.errorClass, "BAD_ARG",
+        "before must be an array of functions", true));
+    }
+  }
+  if (opts.after !== undefined) {
+    if (!Array.isArray(opts.after) || !opts.after.every(function (f) { return typeof f === "function"; })) {
+      return Promise.reject(_makeError(opts.errorClass, "BAD_ARG",
+        "after must be an array of functions", true));
+    }
+  }
+  if (opts.onUploadProgress !== undefined && typeof opts.onUploadProgress !== "function") {
+    return Promise.reject(_makeError(opts.errorClass, "BAD_ARG",
+      "onUploadProgress must be a function", true));
+  }
+  if (opts.onDownloadProgress !== undefined && typeof opts.onDownloadProgress !== "function") {
+    return Promise.reject(_makeError(opts.errorClass, "BAD_ARG",
+      "onDownloadProgress must be a function", true));
+  }
+
+  // before interceptors — run in array order. Each may return a modified
+  // opts object (or return nothing to leave the running opts as-is).
+  // Caller-set defaults / observability / auth header injection lands
+  // here. Synchronous to keep the request hot path simple; async
+  // pre-flight work (e.g. token refresh) belongs in the route handler
+  // before httpClient.request is even called.
+  if (Array.isArray(opts.before) && opts.before.length > 0) {
+    var working = opts;
+    for (var bi = 0; bi < opts.before.length; bi++) {
+      var ret;
+      try { ret = opts.before[bi](working); }
+      catch (e) {
+        return Promise.reject(_makeError(opts.errorClass, "BEFORE_THREW",
+          "before[" + bi + "] threw: " + ((e && e.message) || String(e)), true));
+      }
+      if (ret && typeof ret === "object") working = ret;
+    }
+    opts = working;
+  }
+
   // Multipart shorthand: { multipart: { fields, files } } expands to
   // body + Content-Type with the boundary parameter. Mutually exclusive
   // with caller-supplied body / Content-Type.
@@ -413,11 +457,23 @@ function request(opts) {
         "maxRedirects must be a non-negative integer or null", true));
     }
   }
+  var afterChain = (Array.isArray(opts.after) && opts.after.length > 0) ? opts.after : null;
+  function _runAfter(finalOpts, res) {
+    if (!afterChain) return res;
+    for (var ai = 0; ai < afterChain.length; ai++) {
+      try { afterChain[ai](finalOpts, res); }
+      catch (_e) { /* after hooks are best-effort — never break the response */ }
+    }
+    return res;
+  }
+
   if (maxRedirects === null || maxRedirects === 0) {
-    return _requestSingle(opts);
+    return _requestSingle(opts).then(function (res) { return _runAfter(opts, res); });
   }
 
-  return _requestWithRedirects(opts, maxRedirects);
+  return _requestWithRedirects(opts, maxRedirects).then(function (boxed) {
+    return _runAfter(boxed.finalOpts, boxed.res);
+  });
 }
 
 function _requestWithRedirects(opts, hopsLeft) {
@@ -431,9 +487,11 @@ function _requestWithRedirects(opts, hopsLeft) {
   var current = Object.assign({}, opts, { _resolveOnRedirect: true });
   function _follow() {
     return _requestSingle(current).then(function (res) {
-      if (!REDIRECT_STATUSES.has(res.statusCode) || hopsLeft <= 0) return res;
+      if (!REDIRECT_STATUSES.has(res.statusCode) || hopsLeft <= 0) {
+        return { finalOpts: current, res: res };
+      }
       var loc = res.headers && (res.headers.location || res.headers.Location);
-      if (!loc) return res;        // 3xx with no Location — operator handles
+      if (!loc) return { finalOpts: current, res: res };  // 3xx with no Location — operator handles
       hopsLeft -= 1;
 
       // Resolve relative Location against the just-fetched URL (the URL
@@ -562,9 +620,26 @@ function _requestH1(transport, u, opts) {
     function _resolve(value) { if (!settled) { settled = true; resolve(value); } }
     function _reject(err)    { if (!settled) { settled = true; reject(err); } }
 
+    var onUploadProgress   = typeof opts.onUploadProgress === "function" ? opts.onUploadProgress : null;
+    var onDownloadProgress = typeof opts.onDownloadProgress === "function" ? opts.onDownloadProgress : null;
+
     var req = transport.lib.request(reqOpts, function (res) {
       if (observer) observer("response:headers", { statusCode: res.statusCode, headers: res.headers });
 
+      // Download total: Content-Length when present, null otherwise.
+      var dlTotal = null;
+      if (res.headers && typeof res.headers["content-length"] === "string") {
+        var cl = parseInt(res.headers["content-length"], 10);
+        if (!isNaN(cl) && cl >= 0) dlTotal = cl;
+      }
+      var dlLoaded = 0;
+      function _emitDownload(chunkBytes) {
+        if (!onDownloadProgress) return;
+        dlLoaded += chunkBytes;
+        try { onDownloadProgress({ loaded: dlLoaded, total: dlTotal }); }
+        catch (_e) { /* progress hooks are best-effort */ }
+      }
+
       if (responseMode === "stream") {
         if (res.statusCode >= 400) {
           res.resume();
@@ -572,6 +647,17 @@ function _requestH1(transport, u, opts) {
             "HTTP " + res.statusCode + " " + (res.statusMessage || ""),
             _isPermanentStatus(res.statusCode), res.statusCode));
         }
+        if (onDownloadProgress) {
+          // Wrap the stream so chunks emit progress to the operator.
+          // The framework's contract is to hand back the response stream
+          // unmodified; fix-up via a passthrough keeps that contract while
+          // observing the chunk sizes.
+          var passthrough = new (require("node:stream").PassThrough)();
+          res.on("data", function (chunk) { _emitDownload(chunk.length); passthrough.write(chunk); });
+          res.on("end",  function () { passthrough.end(); });
+          res.on("error", function (e) { passthrough.destroy(e); });
+          return _resolve({ statusCode: res.statusCode, headers: res.headers, body: passthrough });
+        }
         return _resolve({ statusCode: res.statusCode, headers: res.headers, body: res });
       }
 
@@ -586,7 +672,9 @@ function _requestH1(transport, u, opts) {
           req.destroy();
           _reject(_makeError(opts.errorClass, "RESPONSE_TOO_LARGE",
             "response body exceeds " + maxResponseBytes + " bytes", true));
+          return;
         }
+        _emitDownload(chunk.length);
       });
       res.on("end", function () {
         if (capExceeded) return;
@@ -639,17 +727,47 @@ function _requestH1(transport, u, opts) {
       signal.addEventListener("abort", onAbort, { once: true });
     }
 
+    // Upload progress: emit { loaded, total } as body bytes go to the
+    // wire. Buffer / string bodies are sliced into chunks ourselves so
+    // operators see incremental progress; Readable bodies emit on each
+    // 'data' event from the source stream.
+    var ulTotal = null;
+    if (Buffer.isBuffer(opts.body)) ulTotal = opts.body.length;
+    else if (typeof opts.body === "string") ulTotal = Buffer.byteLength(opts.body, "utf8");
+    var ulLoaded = 0;
+    function _emitUpload(chunkBytes) {
+      if (!onUploadProgress) return;
+      ulLoaded += chunkBytes;
+      try { onUploadProgress({ loaded: ulLoaded, total: ulTotal }); }
+      catch (_e) { /* progress hooks are best-effort */ }
+    }
+
     if (opts.body && typeof opts.body.pipe === "function") {
+      if (onUploadProgress) {
+        opts.body.on("data", function (c) { _emitUpload(c.length); });
+      }
       opts.body.on("error", function (e) {
         try { req.destroy(); } catch (_) {}
         _reject(_makeError(opts.errorClass, "REQ_BODY_ERROR",
           "request body stream error: " + e.message, false));
       });
       opts.body.pipe(req);
-    } else if (Buffer.isBuffer(opts.body)) {
-      req.end(opts.body);
-    } else if (typeof opts.body === "string") {
-      req.end(Buffer.from(opts.body, "utf8"));
+    } else if (Buffer.isBuffer(opts.body) || typeof opts.body === "string") {
+      var bodyBuf = Buffer.isBuffer(opts.body) ? opts.body : Buffer.from(opts.body, "utf8");
+      if (onUploadProgress) {
+        // Chunked write so progress reports land before req.end().
+        var CHUNK = 64 * 1024;
+        var off = 0;
+        while (off < bodyBuf.length) {
+          var slice = bodyBuf.slice(off, Math.min(off + CHUNK, bodyBuf.length));
+          req.write(slice);
+          _emitUpload(slice.length);
+          off += slice.length;
+        }
+        req.end();
+      } else {
+        req.end(bodyBuf);
+      }
     } else {
       req.end();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",