react-router-effect 2.1.0 → 2.2.0

package/src/vite.ts

@@ -6,23 +6,36 @@
  * serves the client: route modules, `/@vite/client`, the files of `public/`,
  * and its error overlay. A custom server runs Vite in middleware mode and passes
  * it each request first. Vite's middleware is a Connect stack of Node
- * requests and responses, so this middleware needs Effect's Node HTTP server.
+ * requests and responses, so this layer needs Effect's Node HTTP server.
  *
+ * Its API is unstable: a minor version can change it.
+ *
+ * @stability unstable
  * @since 2.1.0
  */
 import type * as Http from "node:http";
 
 import * as NodeHttpServerRequest from "@effect/platform-node/NodeHttpServerRequest";
-import { Effect } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import { Effect, Exit, Layer, Option, Predicate, Scope, SynchronizedRef, Tuple } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
 
-/** The part of a Vite dev server the middleware uses: its Connect middleware stack. */
+/**
+ * The parts of a Vite dev server that the adapter uses.
+ *
+ * @stability unstable
+ */
 export interface ViteDevServer {
+  /** Vite's Connect middleware stack. */
   readonly middlewares: (
     request: Http.IncomingMessage,
     response: Http.ServerResponse,
     next: (error?: unknown) => void,
   ) => void;
+  /**
+   * Maps the stack of an error to the source files, as the Express template
+   * does. Vite's dev server has it.
+   */
+  readonly ssrFixStacktrace?: ((error: Error) => void) | undefined;
 }
 
 /**
@@ -57,36 +70,100 @@ const passThroughVite = (
   });
 
 /**
- * Passes each request to Vite first, and the requests Vite passes on to the
- * app. Use it in development only, with Vite in middleware mode:
- *
- * ```ts
- * import { ReactRouterVite } from "react-router-effect/vite";
+ * Serves the app in development, as the Express template does. Give it to
+ * `HttpRouter.serve` in place of the app's `App`:
  *
+ * ```js
  * const vite = await createServer({ server: { middlewareMode: true } });
- * HttpServer.serve(Effect.flatten(reactRouterApp).pipe(ReactRouterVite.devMiddleware(vite)));
+ * const App = ReactRouterVite.layer(vite, () =>
+ *   vite.ssrLoadModule("./server/app.ts").then((module) => module.App),
+ * );
  * ```
  *
- * A request Vite answers gets an empty `HttpServerResponse`, which Effect's
- * Node server does not write, since Vite has ended the Node response. A Vite
- * error fails the request as a defect.
+ * The layer registers one catch-all route on the server's router. Its
+ * handler passes each request to Vite first. For a request that Vite passes
+ * on, it calls `loadApp`. When `loadApp` returns a new `App` value, such as
+ * after an edit of the app's server code, the layer builds the new `App` with
+ * its own router and closes the old one. Concurrent requests share one build
+ * of each `App`. Then the request goes through the current `App`.
+ *
+ * A request that Vite answers gets an empty `HttpServerResponse`, which
+ * Effect's Node server does not write, since Vite has ended the Node
+ * response. A defect, such as a Vite error, a `loadApp` that rejects or an
+ * `App` that fails to build, goes to the app's loggers, after
+ * `ssrFixStacktrace` maps its stack, and the client gets an empty 500.
+ *
+ * @stability unstable
  */
-export const devMiddleware =
-  (vite: ViteDevServer) =>
-  <E, R>(
-    app: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>,
-  ): Effect.Effect<
-    HttpServerResponse.HttpServerResponse,
-    E,
-    R | HttpServerRequest.HttpServerRequest
-  > =>
-    HttpServerRequest.HttpServerRequest.use((request) =>
-      passThroughVite(
-        vite,
-        // Vite takes HTTP/1 requests; Effect's Node server serves HTTP/1.
-        NodeHttpServerRequest.toIncomingMessage(request) as Http.IncomingMessage,
-        NodeHttpServerRequest.toServerResponse(request) as Http.ServerResponse,
-      ).pipe(
-        Effect.flatMap((passed) => (passed ? app : Effect.succeed(HttpServerResponse.empty()))),
-      ),
-    );
+export const layer = <E, R>(
+  vite: ViteDevServer,
+  loadApp: () => PromiseLike<Layer.Layer<never, E, R>>,
+) =>
+  HttpRouter.use((router) =>
+    Effect.gen(function* () {
+      const layerScope = yield* Effect.scope;
+      const services =
+        yield* Effect.context<Exclude<HttpRouter.Request.Without<R>, HttpRouter.HttpRouter>>();
+      /** Builds `app` in `scope`. The services of this layer do not replace either. */
+      const build = (app: Layer.Layer<never, E, R>, scope: Scope.Scope) =>
+        HttpRouter.toHttpEffect(app).pipe(
+          Scope.provide(scope),
+          // A new memo map, so the App gets its own router. The memo map of the
+          // server's layers has the server's router, and a fork of it reuses it.
+          Effect.provideServiceEffect(Layer.CurrentMemoMap, Layer.makeMemoMap),
+          Effect.provideContext(services),
+        );
+      type Handler = Effect.Success<ReturnType<typeof build>>;
+      interface Built {
+        readonly app: Layer.Layer<never, E, R>;
+        readonly handler: Handler;
+        readonly scope: Scope.Closeable;
+      }
+      const state = yield* SynchronizedRef.make(Option.none<Built>());
+
+      /** The handler of `app`, built once for each `App` value. */
+      const handlerOf = (app: Layer.Layer<never, E, R>) =>
+        SynchronizedRef.modifyEffect(state, (previous) =>
+          Effect.gen(function* () {
+            if (Option.isSome(previous) && previous.value.app === app) {
+              return Tuple.make(previous.value.handler, previous);
+            }
+            const scope = yield* Scope.fork(layerScope);
+            const handler = yield* build(app, scope).pipe(
+              Effect.onExit((exit) =>
+                Exit.isSuccess(exit) ? Effect.void : Scope.close(scope, exit),
+              ),
+              Effect.orDie,
+            );
+            if (Option.isSome(previous)) yield* Scope.close(previous.value.scope, Exit.void);
+            return Tuple.make(handler, Option.some<Built>({ app, handler, scope }));
+          }).pipe(
+            // A client that leaves during a build does not stop it: the build
+            // is shared, and a stop could leave a scope open or drop a build.
+            Effect.uninterruptible,
+          ),
+        );
+
+      const handler = HttpServerRequest.HttpServerRequest.use((request) =>
+        passThroughVite(
+          vite,
+          // Vite takes HTTP/1 requests; Effect's Node server serves HTTP/1.
+          NodeHttpServerRequest.toIncomingMessage(request) as Http.IncomingMessage,
+          NodeHttpServerRequest.toServerResponse(request) as Http.ServerResponse,
+        ).pipe(
+          Effect.flatMap((passed) =>
+            passed
+              ? Effect.promise(loadApp).pipe(Effect.flatMap(handlerOf), Effect.flatten)
+              : Effect.succeed(HttpServerResponse.empty()),
+          ),
+          Effect.catchDefect((defect) => {
+            if (Predicate.isError(defect)) vite.ssrFixStacktrace?.(defect);
+            return Effect.logError("Request failed in development", defect).pipe(
+              Effect.as(HttpServerResponse.empty({ status: 500 })),
+            );
+          }),
+        ),
+      );
+      yield* router.add("*", "*", handler);
+    }),
+  );