@bakery-framework/core 2.2.0 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakery-framework/core",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Bakery framework core: handlers, router, config, session, caches, logger, compiler.",
   "keywords": [
     "bakery",

package/src/cache/index.ts

@@ -1,5 +1,21 @@
 import { Bakery } from '../core/bakery'
+import { HandlerMap } from '../handlers/core/$registry'
+
+/**
+ * The dev watcher's route reset, run on every change to a route file: each
+ * handler's own caches, and `HandlerMap.routeCache` with them.
+ *
+ * The route cache is what a created file needs cleared. It remembers which
+ * handler won a path, and a hit re-asks only that handler, so a winner that
+ * still says yes keeps the path after a file that outranks it appears.
+ * `StaticHandler` says yes to every path. Measured in a dev app: with a root
+ * catch-all deleted and `/` requested (404, as livereload does on the delete),
+ * `/` still answered 404 three seconds after `index.vue` was written, until
+ * the dev worker restarted. And `/about` kept serving `about.html` after an
+ * `about.vue` (VueHandler, 58, above HTMLHandler, 55) was written beside it.
+ */
 export function initRoutes() {
+  HandlerMap.routeCache.clear()
   for (const [, handlers] of Object.entries(Bakery.handlers)) {
     for (const HandlerClass of handlers.list()) {
       HandlerClass.initRoutes()

package/src/compiler/dev-service.ts

@@ -456,9 +456,8 @@ const watchIgnores = Glob.strings(
 // restart was Bun's module registry caching the imported page module, and
 // TSXHandler now busts that per request in dev exactly as ApiHandler always
 // has. Pages take the cheap path via `tsScriptGlob` above. The one thing the
-// restart still bought (flushing *components* a page imports) is a
-// documented limitation (docs/getting-started/first-app.md): touch
-// server.config.ts or restart when editing a shared Layout.tsx.
+// restart still bought, flushing the *components* a page imports,
+// `isLoadedModule` now does for exactly the files that need it.
 const prioFilesGlob = Glob.strings('server.config.ts')
 
 /**
@@ -563,6 +562,45 @@ export function isCreatedRouteModule(
   return MODULE_ROUTE_EXT.test(filePath)
 }
 
+/**
+ * Whether `filePath` is a module this process imported through a plain
+ * specifier, so Bun's registry keeps serving the copy it already has and an
+ * edit cannot reach the running server without a restart.
+ *
+ * Routes are imported cache-busted (`bustInDev`'s `?v=<mtime>`), and the
+ * registry keys those with their query, so an edited route is not one: the
+ * next request imports it under a new key. Everything a route imports is
+ * keyed bare, and that is what used to go stale: a component a page imports
+ * (a shared `Layout.tsx`), and a helper an API route imports from outside the
+ * api directory, such as a top-level `server/` folder of permission checks.
+ * Measured in a dev app: an edit to `server/auth.ts` did not apply until a
+ * file under `src/api` was touched.
+ *
+ * `require.cache` is where Bun lists them, ES modules included (1.4.2: a
+ * static import keyed by path, `a.ts?v=1` keyed with its query). A Bun that
+ * stopped listing them would turn this back into the old behavior rather than
+ * break anything, and `dev-service.test.ts` asks the real registry, so it
+ * would say so.
+ */
+export function isLoadedModule(
+  filePath: string,
+  loaded: Iterable<string> = Object.keys(require.cache),
+  cwd: string = fs.cwd,
+): boolean {
+  const target = modulePathKey(resolve(cwd, filePath))
+  for (const key of loaded) {
+    if (!key.includes('?') && modulePathKey(key) === target) return true
+  }
+  return false
+}
+
+/** One spelling of a path for comparison: forward slashes, and case-folded
+ * on Windows, where `Auth.ts` and `auth.ts` are one file. */
+function modulePathKey(path: string): string {
+  const slashed = path.replaceAll('\\', '/')
+  return process.platform === 'win32' ? slashed.toLowerCase() : slashed
+}
+
 async function processFileEvent(
   filePath: string,
   server: any,
@@ -588,6 +626,12 @@ async function processFileEvent(
       return process.exit(42)
     }
 
+    // A module the server holds a plain copy of: see `isLoadedModule`.
+    if (isLoadedModule(filePath)) {
+      serveLog.BACKEND_CHANGE({ file: filePath })
+      return process.exit(42)
+    }
+
     if (tsScriptGlob.match(filePath)) {
       initRoutes()
       return notifySockets(server, filePath)

package/src/handlers/core/$dynamic.ts

@@ -35,9 +35,10 @@ const dynamicCaches = new Map<any, HandlerCache<RegExp, Route.Info>>()
  * a bare `PROD` gate flipped mid-suite and broke the reload tests in files
  * loaded after it, while passing in isolation.
  *
- * Only the route module itself is busted: components it imports (a shared
- * `Layout.tsx`, helpers) stay in Bun's registry until a restart. Documented in
- * `docs/getting-started/first-app.md`.
+ * Only the route module itself is busted: components and helpers it imports
+ * (a shared `Layout.tsx`) stay in Bun's registry, and the dev watcher restarts
+ * the worker when one of them changes (`isLoadedModule` in
+ * compiler/dev-service.ts).
  *
  * One implementation on purpose. `ApiHandler` and `TSXHandler`/`TSXErrorHandler`
  * both need it, and they carried a byte-identical copy each (including this