arcway 0.1.21 → 0.1.23

package/server/pages/pages-router.js

@@ -1,5 +1,5 @@
-import { createPagesBuildContext } from './build-context.js';
 import { createPagesHandler } from './handler.js';
+import { createLazyPagesContext } from './lazy-context.js';
 import { createPagesWatcher } from './watcher.js';
 
 class PagesRouter {
@@ -10,7 +10,7 @@ class PagesRouter {
   fileWatcher;
   handler = null;
   watcher = null;
-  pagesBuildContext = null;
+  lazyContext = null;
 
   constructor(config, { rootDir, log, mode, fileWatcher, appContext }) {
     this.config = config;
@@ -25,24 +25,22 @@ class PagesRouter {
     const { config, rootDir, log, mode, fileWatcher } = this;
     const isDev = mode === 'development';
 
-    let initialClientMetafile;
     if (isDev) {
-      // Dev mode owns a long-lived `createPagesBuildContext()` so the watcher
-      // can do incremental `ctx.rebuild()` on file change instead of a cold
-      // `buildPages()`. The initial rebuild bootstraps the outDir and captures
-      // the client metafile used for HMR diffs.
+      // Dev mode: `createLazyPagesContext()` builds only the shared bits
+      // (client bundle, CSS, error pages, HMR runtime) at startup. Per-page /
+      // layout / middleware server bundles compile on first request via
+      // `ensurePageBuilt()` threaded through the handler. The watcher
+      // translates file changes into per-entry invalidations on this context.
       try {
-        this.pagesBuildContext = await createPagesBuildContext({
+        this.lazyContext = await createLazyPagesContext({
           rootDir,
           pagesDir: config.pages.dir,
           fonts: config.pages?.fonts,
           minify: false,
           devMode: true,
         });
-        const result = await this.pagesBuildContext.rebuild();
-        initialClientMetafile = result.clientMetafile;
       } catch (err) {
-        log.error('Pages build failed', { error: String(err) });
+        log.error('Pages lazy context init failed', { error: String(err) });
       }
     }
 
@@ -51,23 +49,20 @@ class PagesRouter {
       session: config.session,
       appContext: this.appContext,
       mode,
+      ...(this.lazyContext ? { lazyContext: this.lazyContext } : {}),
     });
 
     if (!this.handler) return;
 
     log.info('Pages: SSR enabled');
 
-    if (isDev && fileWatcher) {
+    if (isDev && fileWatcher && this.lazyContext) {
       this.watcher = createPagesWatcher({
-        rootDir,
-        handler: this.handler,
+        lazyContext: this.lazyContext,
         log,
-        fonts: config.pages?.fonts,
-        initialClientMetafile,
         fileWatcher,
-        pagesBuildContext: this.pagesBuildContext,
       });
-      log.info('Pages: watching for changes (HMR enabled)');
+      log.info('Pages: watching for changes (per-entry invalidate)');
     }
   }
 
@@ -81,9 +76,9 @@ class PagesRouter {
       await this.watcher.close();
       this.watcher = null;
     }
-    if (this.pagesBuildContext) {
-      await this.pagesBuildContext.dispose();
-      this.pagesBuildContext = null;
+    if (this.lazyContext) {
+      await this.lazyContext.dispose();
+      this.lazyContext = null;
     }
   }
 }

package/server/pages/watcher.js

@@ -1,88 +1,46 @@
-import path from 'node:path';
-import { buildPages } from './build.js';
-import { diffClientMetafiles } from './hmr.js';
+// Dev-only watcher that translates file-system events into per-entry
+// invalidations or structural rediscovery on the lazy pages context.
+//
+// Change events (file edits) flip the affected manifest entries to
+// `stale: true` and bump the version; the next request for that route
+// drives the actual rebuild through `ensurePageBuilt()`. There is no
+// serialization flag here -- lazy builds are per-entry and already
+// coalesced inside the context.
+//
+// Structural events (`add` / `unlink` of page / layout / middleware
+// files) trigger a single `lazyContext.rediscover()` per debounced batch.
+// Rediscover diffs the manifest against discovery output, applies
+// adds/removes, cascades stale flags through layout/middleware chains,
+// and tears down + recreates the client esbuild context when the page
+// or layout set changes.
 
 function createPagesWatcher(options) {
-  const { rootDir, handler, log, fonts, fileWatcher, pagesBuildContext } = options;
-  let building = false;
-  let pendingRebuild = false;
-  let pendingStructuralChange = false;
-  let prevClientMetafile = options.initialClientMetafile;
-  const outDir = path.resolve(rootDir, '.build/pages');
-
-  async function runBuild() {
-    if (pagesBuildContext) return pagesBuildContext.rebuild();
-    return buildPages({ rootDir, fonts, minify: false, devMode: true });
-  }
-
-  async function rebuild(isStructuralChange) {
-    if (building) {
-      pendingRebuild = true;
-      if (isStructuralChange) pendingStructuralChange = true;
-      return;
-    }
-    building = true;
-    try {
-      const start = Date.now();
-      const result = await runBuild();
-      handler.reload();
-      const elapsed = Date.now() - start;
-      if (handler.emitEvent && prevClientMetafile && result.clientMetafile && !isStructuralChange) {
-        const diff = diffClientMetafiles(prevClientMetafile, result.clientMetafile, outDir);
-        const hmrModules = [...diff.changedNavBundles, ...diff.changedHydrationBundles];
-        if (diff.needsFullReload) {
-          handler.emitEvent({ type: 'reload' });
-          log.info(`Pages rebuilt in ${elapsed}ms (full reload)`);
-        } else if (hmrModules.length > 0) {
-          const manifestJson = handler.getClientManifestJson?.();
-          handler.emitEvent({
-            type: 'hmr-update',
-            modules: hmrModules,
-            timestamp: Date.now(),
-            ...(manifestJson ? { manifest: manifestJson } : {}),
-          });
-          log.info(
-            `Pages rebuilt in ${elapsed}ms (HMR: ${hmrModules.length} module(s))`,
-          );
-        } else if (diff.changedCssBundle) {
-          handler.emitEvent({
-            type: 'css-update',
-            cssBundle: diff.changedCssBundle,
-            timestamp: Date.now(),
-          });
-          log.info(`Pages rebuilt in ${elapsed}ms (CSS update)`);
-        } else {
-          log.info(`Pages rebuilt in ${elapsed}ms (no client changes)`);
-        }
-      } else {
-        if (handler.emitEvent) {
-          handler.emitEvent({ type: 'reload' });
-        }
-        log.info(`Pages rebuilt in ${elapsed}ms`);
-      }
-      prevClientMetafile = result.clientMetafile;
-    } catch (err) {
-      log.error('Pages rebuild failed', { error: String(err) });
-    } finally {
-      building = false;
-      if (pendingRebuild) {
-        pendingRebuild = false;
-        const structural = pendingStructuralChange;
-        pendingStructuralChange = false;
-        await rebuild(structural);
-      }
-    }
+  const { lazyContext, log, fileWatcher } = options;
+  if (!lazyContext) {
+    throw new Error('createPagesWatcher requires a lazyContext');
   }
 
   fileWatcher.subscribe('pages', {
     extensions: ['.tsx', '.jsx', '.ts', '.js', '.css'],
     debounceMs: 150,
-    onChange(events) {
-      const isStructural = events.some((e) => e.event === 'add' || e.event === 'unlink');
+    async onChange(events) {
+      const hasStructural = events.some((e) => e.event === 'add' || e.event === 'unlink');
+      if (hasStructural) {
+        try {
+          const result = await lazyContext.rediscover();
+          const summary = formatRediscover(result);
+          if (summary) log.info(`Pages: rediscovered (${summary})`);
+        } catch (err) {
+          log.error(`Pages: rediscover failed — ${String(err)}`);
+        }
+      }
       for (const e of events) {
-        log.info(`Page ${e.event === 'unlink' ? 'removed' : e.event === 'add' ? 'added' : 'changed'}: ${e.relativePath}`);
+        if (e.event !== 'change') continue;
+        const result = lazyContext.invalidate(e.path);
+        if (result.touched) {
+          log.info(`Pages: invalidated ${e.relativePath} (${formatAffected(result.affected)})`);
+        }
       }
-      return rebuild(isStructural);
     },
   });
 
@@ -93,4 +51,29 @@ function createPagesWatcher(options) {
   };
 }
 
+function formatAffected(affected) {
+  const parts = [];
+  if (affected.pages.length) parts.push(`${affected.pages.length} page(s)`);
+  if (affected.layouts.length) parts.push(`${affected.layouts.length} layout(s)`);
+  if (affected.middlewares.length) parts.push(`${affected.middlewares.length} middleware(s)`);
+  return parts.length ? parts.join(', ') : 'no entries';
+}
+
+function formatRediscover(result) {
+  const parts = [];
+  const { added, removed, staleByCascade, clientRebuilt } = result;
+  if (added.pages.length || removed.pages.length) {
+    parts.push(`pages +${added.pages.length}/-${removed.pages.length}`);
+  }
+  if (added.layouts.length || removed.layouts.length) {
+    parts.push(`layouts +${added.layouts.length}/-${removed.layouts.length}`);
+  }
+  if (added.middlewares.length || removed.middlewares.length) {
+    parts.push(`middlewares +${added.middlewares.length}/-${removed.middlewares.length}`);
+  }
+  if (staleByCascade.length) parts.push(`${staleByCascade.length} cascaded stale`);
+  if (clientRebuilt) parts.push('client rebuilt');
+  return parts.join(', ');
+}
+
 export { createPagesWatcher };

package/server/watcher.js

@@ -1,8 +1,21 @@
 import { watch } from 'chokidar';
 import path from 'node:path';
 function startWatcher(options) {
-  const dirs = options.dirs ?? ['api', 'lib', 'listeners', 'jobs'];
-  const extensions = new Set(options.extensions ?? ['.js']);
+  const dirs = options.dirs ?? [
+    'api',
+    'pages',
+    'components',
+    'hooks',
+    'lib',
+    'listeners',
+    'jobs',
+    'packages',
+    'server',
+    'templates',
+    'migrations',
+    'seeds',
+  ];
+  const extensions = new Set(options.extensions ?? ['.js', '.jsx', '.ts', '.tsx', '.css']);
   const debounceMs = options.debounceMs ?? 300;
   const watchPaths = dirs.map((dir) => path.join(options.rootDir, dir));
   let debounceTimer = null;

package/server/ws/ws-router.js

@@ -2,6 +2,7 @@ import { Server as SocketIOServer } from 'socket.io';
 import { randomUUID } from 'node:crypto';
 import { registerWsServer, unregisterWsServer } from './registry.js';
 import { parseCookies, resolveSession, flattenHeaders } from '../session/helpers.js';
+import { getMiddlewareForRoute } from '../router/middleware.js';
 import { toErrorMessage } from '../helpers.js';
 
 class WsRouter {
@@ -199,9 +200,38 @@ class WsRouter {
     }
 
     const reqInfo = this._buildRequestInfo(client, { ...wsMsg, method: 'GET' }, params);
+    const ctx = this._apiRouter.buildCtx(reqInfo);
+
+    // Run api/_middleware.js chain BEFORE invoking route.config.ws(). Without
+    // this, ws() side effects (listener registration, resource allocation,
+    // initial emits) fire even when auth middleware would have rejected the
+    // subscribe. Matches the gating already in place for _handleMethodCall,
+    // which routes through executeRoute() (middleware-first).
+    const middlewareFns = getMiddlewareForRoute(this._apiRouter.middleware, route.pattern, 'GET');
+    for (const mw of middlewareFns) {
+      let result;
+      try {
+        result = await mw(ctx);
+      } catch (err) {
+        this._log.error(`WS subscribe middleware error for ${msgPath}`, {
+          error: toErrorMessage(err),
+        });
+        this._send(client, {
+          path: msgPath,
+          error: { code: 'MIDDLEWARE_ERROR', message: 'Middleware error' },
+          status: 500,
+          id: wsMsg.id,
+        });
+        return;
+      }
+      if (result !== undefined && result !== null) {
+        this._send(client, { path: msgPath, ...result, id: wsMsg.id });
+        return;
+      }
+    }
+
     let cleanup;
     try {
-      const ctx = this._apiRouter.buildCtx(reqInfo);
       cleanup = await route.config.ws(ctx);
     } catch (err) {
       this._log.error(`WS subscribe error for ${msgPath}`, {
@@ -221,7 +251,20 @@ class WsRouter {
       req: reqInfo,
     });
 
-    const response = await this._apiRouter.executeRoute(route, reqInfo);
+    // Middleware already ran above; invoke the handler directly to avoid
+    // executing the chain a second time via executeRoute().
+    let response;
+    try {
+      response = await route.config.handler(ctx);
+    } catch (err) {
+      this._log.error(`WS subscribe handler error for GET ${route.pattern}`, {
+        error: toErrorMessage(err),
+      });
+      response = {
+        status: 500,
+        error: { code: 'HANDLER_ERROR', message: 'An internal error occurred' },
+      };
+    }
     this._send(client, { path: msgPath, ...response, id: wsMsg.id });
   }