evolit 0.2.1 → 0.4.0

package/src/render.js

@@ -147,6 +147,7 @@ function createRouteModuleOptions(projectRoot, mode, options = {}) {
     staticAssetPublicUrls: resolvedStaticAssetPublicUrls,
     onDevelopmentEvent: options.onDevelopmentEvent,
     managedSourceRoots: options.managedSourceRoots,
+    litsxPipeline: options.litsxPipeline,
   };
 }
 

package/src/server-setup.js

@@ -0,0 +1,65 @@
+import path from "node:path";
+import { importCompiledModule, resolveProjectModuleSpecifier } from "./compiler.js";
+
+function resolveSetupExport(moduleRecord, setupPath) {
+  const setup = moduleRecord.setup ?? moduleRecord.default;
+  if (typeof setup !== "function") {
+    throw new TypeError(
+      `Expected server setup module ${JSON.stringify(setupPath)} to export a setup function or a default function.`,
+    );
+  }
+  return setup;
+}
+
+function normalizeCleanup(result) {
+  if (result == null) return null;
+  if (typeof result === "function") return result;
+  if (typeof result === "object" && typeof result.dispose === "function") {
+    return () => result.dispose();
+  }
+  throw new TypeError("Evolit server setup must return nothing, a cleanup function, or an object with dispose().");
+}
+
+/** Runs the application server bootstrap once for a build or runtime instance. */
+export async function runServerSetup({ projectRoot, mode, evolitConfig = {}, litsxPipeline = null }) {
+  const serverConfig = evolitConfig.server;
+  if (serverConfig == null) return null;
+  if (!serverConfig || typeof serverConfig !== "object" || Array.isArray(serverConfig)) {
+    throw new TypeError("Expected server in evolit.config.js to be an object.");
+  }
+
+  const configuredSetup = serverConfig.setup;
+  if (configuredSetup == null) return null;
+
+  let setup = configuredSetup;
+  if (typeof configuredSetup === "string") {
+    if (configuredSetup.length === 0) {
+      throw new TypeError("Expected server.setup to be a non-empty module specifier.");
+    }
+    const setupPath = await resolveProjectModuleSpecifier(
+      projectRoot,
+      path.join(projectRoot, "evolit.config.js"),
+      configuredSetup,
+    );
+    if (!setupPath) {
+      throw new Error(`Unable to resolve configured server setup ${JSON.stringify(configuredSetup)}.`);
+    }
+    const moduleRecord = await importCompiledModule(setupPath, {
+      projectRoot,
+      mode,
+      sourceMaps: mode === "development",
+      target: "server",
+      litsxPipeline,
+    });
+    setup = resolveSetupExport(moduleRecord, configuredSetup);
+  }
+
+  if (typeof setup !== "function") {
+    throw new TypeError("Expected server.setup in evolit.config.js to be a function or module specifier.");
+  }
+
+  return normalizeCleanup(await setup({
+    projectRoot,
+    mode,
+  }));
+}

package/src/server.js

@@ -214,6 +214,7 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
     responseCacheRuntime,
     onDevelopmentEvent: reportDevelopmentEvent,
     managedSourceRoots,
+    evolitConfig,
   });
   const port = getPort(explicitPort);
   const liveReloadServer = mode === "development" ? new WebSocketServer({ noServer: true }) : null;
@@ -267,6 +268,7 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
           const response = await deploymentRuntime.handle(
             createDevelopmentNavigationRequest(subscription, origin),
           );
+          syncLitsxDependencyWatchers();
           const navigationResponse = createNavigationResponseFromDocument(response);
           if (!getResponseHeader(navigationResponse.headers, "content-type")
             ?.includes("application/vnd.evolit.navigation+json")) return null;
@@ -341,6 +343,39 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
       { shouldIgnorePath: createSourceWatchIgnorePath(sourceRoot) },
     )))
     : [];
+  const litsxDependencyWatchers = new Map();
+
+  function syncLitsxDependencyWatchers() {
+    if (mode !== "development") return;
+    const activeDependencies = new Set(
+      (deploymentRuntime.litsxDependencies ?? []).map((dependency) => path.resolve(dependency)),
+    );
+    for (const [dependency, watcher] of litsxDependencyWatchers) {
+      if (activeDependencies.has(dependency)) continue;
+      watcher.close();
+      litsxDependencyWatchers.delete(dependency);
+    }
+    for (const resolvedDependency of activeDependencies) {
+      const relativePath = path.relative(projectRoot, resolvedDependency);
+      if (relativePath.split(path.sep).includes(INTERNAL_DIRECTORY)) continue;
+      const isAlreadyManaged = managedSourceRoots.some((sourceRoot) => {
+        const managedRelativePath = path.relative(sourceRoot, resolvedDependency);
+        return managedRelativePath === ""
+          || (managedRelativePath !== ".."
+            && !managedRelativePath.startsWith(`..${path.sep}`)
+            && !path.isAbsolute(managedRelativePath));
+      });
+      if (isAlreadyManaged) continue;
+      if (litsxDependencyWatchers.has(resolvedDependency)) continue;
+      try {
+        const watcher = watch(resolvedDependency, () => scheduleDevelopmentInvalidation(resolvedDependency));
+        watcher.on("error", () => {});
+        litsxDependencyWatchers.set(resolvedDependency, watcher);
+      } catch (error) {
+        if (error?.code !== "ENOENT") throw error;
+      }
+    }
+  }
 
   const server = http.createServer(async (req, res) => {
     try {
@@ -356,6 +391,7 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
       });
       const requestStartedAt = performance.now();
       const response = await deploymentRuntime.handle(request);
+      syncLitsxDependencyWatchers();
       const navigationResponse = String(req.headers.accept ?? "").includes("application/vnd.evolit.navigation+json")
         ? createNavigationResponseFromDocument(response)
         : response;
@@ -384,7 +420,9 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
         error,
       });
       res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
-      res.end(error instanceof Error ? error.stack ?? error.message : String(error));
+      res.end(mode === "development"
+        ? error instanceof Error ? error.stack ?? error.message : String(error)
+        : "Internal Server Error");
     }
   });
 
@@ -416,6 +454,8 @@ async function createServer(projectRoot, mode, explicitPort, options = {}) {
         clearTimeout(invalidationTimer);
       }
       for (const watcher of watchers) watcher.close();
+      for (const watcher of litsxDependencyWatchers.values()) watcher.close();
+      litsxDependencyWatchers.clear();
       for (const socket of liveReloadSockets.keys()) {
         socket.close();
       }

package/src/urql-ssr.js

@@ -26,7 +26,18 @@ export async function getSsrUrqlAdapter() {
  * Evolit owns only lifecycle here; client creation and URQL configuration stay
  * entirely in the application and @litsx/urql.
  */
-export async function runWithOptionalSsrUrqlScope(callback, options = {}) {
+export async function runWithOptionalSsrUrqlScope(
+  contextOrCallback,
+  callbackOrOptions = {},
+  maybeOptions = {},
+) {
+  const hasRequestContext = typeof contextOrCallback !== "function";
+  const requestContext = hasRequestContext ? contextOrCallback : null;
+  const callback = hasRequestContext ? callbackOrOptions : contextOrCallback;
+  const options = hasRequestContext ? maybeOptions : callbackOrOptions;
+  if (typeof callback !== "function") {
+    throw new TypeError("runWithOptionalSsrUrqlScope() expects a render callback.");
+  }
   const adapter = Object.hasOwn(options, "adapter")
     ? options.adapter
     : await getSsrUrqlAdapter();
@@ -34,7 +45,61 @@ export async function runWithOptionalSsrUrqlScope(callback, options = {}) {
     return callback(null);
   }
 
-  return adapter.runWithUrqlScope(() => callback(adapter));
+  return hasRequestContext
+    ? adapter.runWithUrqlScope(requestContext, () => callback(adapter))
+    : adapter.runWithUrqlScope(() => callback(adapter));
+}
+
+/** Creates the HTTP context passed to a request-scoped URQL resource factory. */
+export function createSsrUrqlRequestContext(request) {
+  let didUseRequestData = false;
+  const trackedRequest = new Proxy(request, {
+    get(target, property) {
+      if (property !== "constructor" && property !== Symbol.toStringTag) {
+        didUseRequestData = true;
+      }
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+  });
+  const responseHeaders = new Headers();
+  return {
+    request: trackedRequest,
+    responseHeaders,
+    didUseDynamicRequestData() {
+      return didUseRequestData || !responseHeaders.entries().next().done;
+    },
+  };
+}
+
+function responseHeadersToObject(headers) {
+  const values = Object.fromEntries(headers.entries());
+  if (typeof headers.getSetCookie === "function") {
+    const cookies = headers.getSetCookie();
+    if (cookies.length > 0) values["set-cookie"] = cookies;
+  }
+  return values;
+}
+
+/** Applies request-resource response state before Evolit caches the render. */
+export function applySsrUrqlRequestContext(routeResult, response, context) {
+  if (!context) return response;
+  const urqlHeaders = responseHeadersToObject(context.responseHeaders);
+  if (context.didUseDynamicRequestData()) {
+    routeResult.cachePolicy = { mode: "dynamic" };
+  }
+  if (Object.keys(urqlHeaders).length === 0) return response;
+  routeResult.responseHeaders = {
+    ...(routeResult.responseHeaders ?? {}),
+    ...urqlHeaders,
+  };
+  return {
+    ...response,
+    headers: {
+      ...(response.headers ?? {}),
+      ...urqlHeaders,
+    },
+  };
 }
 
 function escapeJsonForHtml(value) {