arcway 0.1.21 → 0.1.23

package/server/pages/discovery.js

@@ -92,6 +92,103 @@ async function discoverErrorPages(pagesDir) {
   }
   return result;
 }
+// Given a changed file path and an in-memory pages manifest, return the set of
+// manifest entries whose server bundles must be rebuilt. Used by the lazy dev
+// context (#250) so a watcher file-change event can mark only the affected
+// pages/layouts/middlewares stale rather than forcing a full-graph rebuild.
+//
+// Cascade rules:
+//   - Page source edited → the one page whose `srcPath` matches.
+//   - Layout source edited → the layout itself plus every descendant page
+//     (any entry whose `layoutDirs` contains that layout's `dirPath`).
+//   - Middleware source edited → the middleware itself plus every descendant
+//     page (any entry whose `middlewareDirs` contains that middleware's
+//     `dirPath`).
+//   - Anything else → empty. Callers decide whether unrelated file changes
+//     warrant a full re-discovery (e.g. a new page file appeared).
+//
+// All path comparisons go through `path.resolve()` to normalize mixed
+// absolute/relative inputs. `manifest.layouts` and `manifest.middlewares` may
+// be supplied as Maps (the lazy context shape) or plain arrays of
+// `{ dirPath, srcPath }` tuples — both are handled.
+function mapFileToAffected(filePath, manifest) {
+  const result = { pages: [], layouts: [], middlewares: [] };
+  if (!filePath || !manifest) return result;
+  const target = path.resolve(filePath);
+  const entries = manifest.entries ?? [];
+
+  for (const entry of entries) {
+    if (entry.srcPath && path.resolve(entry.srcPath) === target) {
+      result.pages.push(entry.pattern);
+      return result;
+    }
+  }
+
+  const layoutEntries = asDirPathList(manifest.layouts);
+  const hitLayout = layoutEntries.find(
+    (l) => l.srcPath && path.resolve(l.srcPath) === target,
+  );
+  if (hitLayout) {
+    result.layouts.push(hitLayout.dirPath);
+    for (const entry of entries) {
+      if ((entry.layoutDirs ?? []).includes(hitLayout.dirPath)) {
+        result.pages.push(entry.pattern);
+      }
+    }
+    return result;
+  }
+
+  const middlewareEntries = asDirPathList(manifest.middlewares);
+  const hitMw = middlewareEntries.find(
+    (m) => m.srcPath && path.resolve(m.srcPath) === target,
+  );
+  if (hitMw) {
+    result.middlewares.push(hitMw.dirPath);
+    for (const entry of entries) {
+      if ((entry.middlewareDirs ?? []).includes(hitMw.dirPath)) {
+        result.pages.push(entry.pattern);
+      }
+    }
+    return result;
+  }
+
+  return result;
+}
+
+// Accept either Map<dirPath, { srcPath, … }> (lazy context shape) or a plain
+// array of `{ dirPath, srcPath }` tuples (what `discoverLayouts` emits) so the
+// helper works from either side of the refactor without adaptor code.
+function asDirPathList(source) {
+  if (!source) return [];
+  if (Array.isArray(source)) return source;
+  if (source instanceof Map) {
+    return Array.from(source, ([dirPath, value]) => ({ dirPath, ...value }));
+  }
+  return [];
+}
+
+// Construct an in-memory manifest entry for a page. Shared between the
+// lazy context's initial discovery pass and `rediscover()` so both code
+// paths produce structurally identical entries (same chain resolution,
+// same default flags). Resolves layout/middleware/loading dirs against
+// the discovered chain lists rather than the in-memory manifest, which
+// keeps the helper pure.
+function buildPageManifestEntry(page, { layouts, middlewares, loadings }) {
+  return {
+    pattern: page.pattern,
+    paramNames: page.paramNames,
+    ...(page.catchAllParam ? { catchAllParam: page.catchAllParam } : {}),
+    srcPath: path.resolve(page.filePath),
+    layoutDirs: resolveLayoutChain(page.pattern, layouts).map((l) => l.dirPath),
+    middlewareDirs: resolvePageMiddlewareChain(page.pattern, middlewares).map((m) => m.dirPath),
+    loadingDirs: resolveLoadingChain(page.pattern, loadings).map((l) => l.dirPath),
+    sharedChunks: [],
+    sharedCssChunks: [],
+    built: false,
+    stale: false,
+  };
+}
+
 async function discoverStyles(pagesDir) {
   const stylesPath = path.join(pagesDir, '_styles.css');
   try {
@@ -107,12 +204,14 @@ function matchPage(pages, pathname) {
   return { page: result.match, params: result.params };
 }
 export {
+  buildPageManifestEntry,
   discoverErrorPages,
   discoverLayouts,
   discoverLoadings,
   discoverPageMiddleware,
   discoverPages,
   discoverStyles,
+  mapFileToAffected,
   matchPage,
   resolveLayoutChain,
   resolveLoadingChain,

package/server/pages/handler.js

@@ -14,6 +14,7 @@ import {
   syncReactInternals,
 } from './ssr.js';
 import { MIME_TYPES } from './static.js';
+import { createArcwayDevEndpoint } from './arcway-endpoint.js';
 function createPagesHandler(options) {
   const rootDir = options.rootDir;
   const outDir = path.resolve(rootDir, options.outDir ?? '.build/pages');
@@ -22,7 +23,10 @@ function createPagesHandler(options) {
   const appContext = options.appContext ?? null;
   const mode = options.mode ?? 'production';
   const devMode = mode === 'development';
-  if (!fs.existsSync(manifestPath)) {
+  const lazyContext = options.lazyContext ?? null;
+  // Dev with a lazy context drives the handler off an in-memory manifest; no
+  // disk `pages-manifest.json` is produced. Prod still reads from disk.
+  if (!lazyContext && !fs.existsSync(manifestPath)) {
     return null;
   }
   const projectRequire = createRequire(path.join(options.rootDir, 'package.json'));
@@ -32,16 +36,47 @@ function createPagesHandler(options) {
     renderToPipeableStream: projectRequire('react-dom/server').renderToPipeableStream,
   };
   syncReactInternals(projectReactModule);
-  let manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+  let manifest = lazyContext
+    ? lazyContext.manifest
+    : JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
   let routes = compileRoutes(manifest);
   let clientManifestJson = buildClientManifestJson(manifest);
+  let lastSeenVersion = lazyContext ? manifest.version : 0;
   const componentCache = new Map();
   let cacheVersion = 0;
   const reloadEmitter = devMode ? new EventEmitter() : null;
-  if (manifest.entries.length === 0 && !manifest.notFoundBundle && !manifest.errorBundle) {
+  if (
+    !lazyContext &&
+    manifest.entries.length === 0 &&
+    !manifest.notFoundBundle &&
+    !manifest.errorBundle
+  ) {
     return null;
   }
+  // Keep `routes` / `clientManifestJson` in sync with the lazy context's
+  // mutable manifest. Every `built` / `invalidate` event bumps the version,
+  // which is our cheap change signal — recompile only when it moves.
+  function refreshFromLazy() {
+    if (!lazyContext) return;
+    if (manifest.version === lastSeenVersion) return;
+    lastSeenVersion = manifest.version;
+    routes = compileRoutes(manifest);
+    clientManifestJson = buildClientManifestJson(manifest);
+    componentCache.clear();
+    cacheVersion++;
+  }
+  if (lazyContext) {
+    lazyContext.on('update', (event) => {
+      refreshFromLazy();
+      if (reloadEmitter) reloadEmitter.emit('update', event);
+    });
+  }
+  const arcwayEndpoint = lazyContext ? createArcwayDevEndpoint(lazyContext) : null;
   function reload() {
+    if (lazyContext) {
+      refreshFromLazy();
+      return;
+    }
     if (!fs.existsSync(manifestPath)) return;
     manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
     routes = compileRoutes(manifest);
@@ -58,6 +93,9 @@ function createPagesHandler(options) {
     const url = req.url ?? '/';
     const pathname = url.split('?')[0];
     if (method !== 'GET') return false;
+    // Internal `/_arcway/*` endpoints (dev only) resolve before the route
+    // matcher so they can never be shadowed by a user-defined page.
+    if (arcwayEndpoint && arcwayEndpoint(req, res)) return true;
     if (reloadEmitter && pathname === '/__livereload') {
       res.writeHead(200, {
         'Content-Type': 'text/event-stream',
@@ -74,6 +112,9 @@ function createPagesHandler(options) {
       req.on('close', () => reloadEmitter.off('update', onUpdate));
       return true;
     }
+    // Pick up any invalidations or completed builds that landed since the
+    // last request before we resolve the route.
+    refreshFromLazy();
     const matched = matchPageRoute(routes, pathname);
     if (!matched) {
       if (manifest.notFoundBundle) {
@@ -92,6 +133,28 @@ function createPagesHandler(options) {
       }
       return false;
     }
+    // Lazy dev: trigger on-demand build of this page's server bundle +
+    // every ancestor layout/middleware before we attempt to load any
+    // component. ensurePageBuilt() coalesces concurrent calls internally.
+    if (lazyContext) {
+      try {
+        await lazyContext.ensurePageBuilt(matched.route.pattern);
+      } catch (err) {
+        await renderDevBuildError(
+          err,
+          res,
+          manifest,
+          outDir,
+          componentCache,
+          cacheVersion,
+          projectReact,
+        );
+        return true;
+      }
+      refreshFromLazy();
+      const rematched = matchPageRoute(routes, pathname);
+      if (rematched) matched.route = rematched.route;
+    }
     if (matched.route.middlewareServerBundles.length > 0) {
       const middlewareResult = await runPageMiddleware(
         matched.route,
@@ -175,6 +238,43 @@ function createPagesHandler(options) {
       : {}),
   };
 }
+// Render a dev-only build-error page. Preferred path: use the project's
+// `_error.jsx` bundle so devs see the same shell they'd see for runtime errors,
+// with the esbuild message in the `error` prop. Fallback: plain-text 500 when
+// no errorBundle is available or the response has already started.
+async function renderDevBuildError(
+  err,
+  res,
+  manifest,
+  outDir,
+  componentCache,
+  cacheVersion,
+  projectReact,
+) {
+  const errorMessage = err instanceof Error ? err.message : String(err);
+  if (manifest.errorBundle && !res.headersSent) {
+    await renderErrorPage(
+      manifest.errorBundle,
+      500,
+      { error: errorMessage },
+      outDir,
+      res,
+      componentCache,
+      manifest,
+      cacheVersion,
+      projectReact,
+    );
+    return;
+  }
+  if (!res.headersSent) {
+    const escaped = String(errorMessage)
+      .replace(/&/g, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;');
+    res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(`<h1>500 - Build Error</h1><pre>${escaped}</pre>`);
+  }
+}
 function compileRoutes(manifest) {
   const routes = manifest.entries.map((entry) => {
     const { regex, paramNames, catchAllParam } = compilePattern(entry.pattern);