@bakery-framework/cli 2.2.2 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakery-framework/cli",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "Bakery entry point and process supervision: mode dispatch, dev watcher, cluster.",
   "keywords": [
     "bakery",
@@ -39,10 +39,10 @@
     "bun": ">=1.4.0"
   },
   "dependencies": {
-    "@bakery-framework/core": "^2.2.2"
+    "@bakery-framework/core": "^2.4.0"
   },
   "peerDependencies": {
-    "@bakery-framework/orm": "^2.2.2"
+    "@bakery-framework/orm": "^2.4.0"
   },
   "peerDependenciesMeta": {
     "@bakery-framework/orm": {

package/src/pipeline.ts

@@ -35,12 +35,40 @@ export type RateLimitConfig = Exclude<ProcessedAppConfig['rateLimit'], false>
  * 400 is included: `>= 400`, not `> 400`. A handler returning a bare
  * `new Response(…, {status: 404})` must still reach `TSXErrorHandler` and get
  * the app's error page rather than an empty body.
+ *
+ * A Response whose body the app wrote as a document is not an error to dress,
+ * whatever its status: `hasOwnDocument`. The registry keeps only the status
+ * of what it replaces, so through 2.2.2 an `onRequest` answering with its own
+ * 404 page came back as the app's `error-404.html` (or Bakery's own page),
+ * and an API route's `Response.json({ error }, { status: 404 })` as an
+ * envelope whose message read `404`.
  */
 export function isErrorResult(res: unknown): boolean {
-  if (res instanceof Response) return res.status >= 400
+  if (res instanceof Response) return res.status >= 400 && !hasOwnDocument(res)
   return is.object(res) && 'errorCode' in res
 }
 
+/**
+ * Whether an error Response carries a document of its own: a body typed as
+ * anything but plain text (an HTML page, a JSON document, an uploaded site's
+ * `404.html`).
+ *
+ * What asks to be dressed is untyped or plain text: `response.error()`, a
+ * null body, and a string body such as the router's own
+ * `new Response('Not Found', { status: 404 })`, which Bun leaves untyped until
+ * it is sent. Those still get the app's error page, or the JSON envelope under
+ * `/api`.
+ *
+ * The header alone, never `res.body`: on Bun 1.4.2 reading the body of a Blob
+ * or file Response first makes its `content-type` read `null`, so
+ * `new Response(Bun.file('404.html'), { status: 404 })` would be judged
+ * untyped and dressed.
+ */
+export function hasOwnDocument(res: Response): boolean {
+  const type = res.headers.get('content-type')
+  return Boolean(type) && !/^text\/plain\b/i.test(type!)
+}
+
 /**
  * One bucket a request can be charged to: the top level, or a route rule,
  * checked and ready to match.

package/src/worker.ts

@@ -4,6 +4,7 @@ import {
   hostStore,
 } from '@bakery-framework/core/core/bakery'
 import {
+  checkHostMounts,
   initConfig,
   resolveHostConfig,
 } from '@bakery-framework/core/core/config'
@@ -15,6 +16,7 @@ import {
   handleRequest,
   handleRequestError,
   processResponse,
+  routeOf,
   serveWebSocket,
 } from '@bakery-framework/core/router'
 import { Session } from '@bakery-framework/core/session'
@@ -247,8 +249,10 @@ function settleRequest(
 try {
   // Before anything binds: a rate limit that cannot mean anything (a refill
   // of 0, a prefix without its slash) stops the boot here, naming the field,
-  // in the catch below.
+  // in the catch below. So does a host mount (a path without its slash, a
+  // pattern with '*' inside a label).
   checkRateLimits(Bakery.config)
+  checkHostMounts(Bakery.config)
 
   Bakery.server = Bun.serve({
     port: PORT,
@@ -266,6 +270,9 @@ try {
       const hostConfig = resolveHostConfig(hostname)
 
       return hostStore.run({ config: hostConfig, hostname, req }, async () => {
+        // The limiter keys on the path as sent. An error page is looked up
+        // from `routeOf(req).path` instead, the path routing resolved, so a
+        // page request on a mounted host finds the subtree's error page.
         const path = url.pathname
         req.startNs = Bun.nanoseconds()
         req.__hostname = hostname
@@ -281,7 +288,7 @@ try {
             Bakery.sharedPool.incrementCounter(COUNTER_SLOTS.TOTAL_ERRORS, 1)
             serveLog.SESSION_LOAD_ERR({ error: errorMsg(loadError) })
             return await processResponse(
-              await handleRequestError(path, req, loadError),
+              await handleRequestError(routeOf(req).path, req, loadError),
               req,
             )
           }
@@ -303,7 +310,12 @@ try {
 
             if (isErrorResult(res)) {
               Bakery.sharedPool.incrementCounter(COUNTER_SLOTS.TOTAL_ERRORS, 1)
-              return await handleRequestError(path, req, res)
+              return await handleRequestError(routeOf(req).path, req, res)
+            }
+            // The app's own error page (see `hasOwnDocument`): sent as written,
+            // and still an error answer for the counter.
+            if (res instanceof Response && res.status >= 400) {
+              Bakery.sharedPool.incrementCounter(COUNTER_SLOTS.TOTAL_ERRORS, 1)
             }
             return res
           },
@@ -311,7 +323,7 @@ try {
           async function errorHandler(error) {
             Bakery.sharedPool.incrementCounter(COUNTER_SLOTS.TOTAL_ERRORS, 1)
             serveLog.UNHANDLED_ERR({ error: errorMsg(error) })
-            return await handleRequestError(path, req, error)
+            return await handleRequestError(routeOf(req).path, req, error)
           },
         )