effect-start 0.23.1 → 0.25.0

package/dist/bun/BunServer.js

@@ -1,157 +1,285 @@
-import * as Socket from "../Socket.js";
-import * as Config from "effect/Config";
-import * as Context from "effect/Context";
-import * as Deferred from "effect/Deferred";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Runtime from "effect/Runtime";
-import * as NOs from "node:os";
-import * as NPath from "node:path";
-import * as PathPattern from "../PathPattern.js";
-import * as PlataformRuntime from "../PlatformRuntime.js";
-import * as Route from "../Route.js";
-import * as RouteHttp from "../RouteHttp.js";
-import * as RouteTree from "../RouteTree.js";
-import * as BunRoute from "./BunRoute.js";
-export const BunServer = Context.GenericTag("effect-start/BunServer");
-export const make = (options) => Effect.gen(function* () {
-    const routes = yield* Effect.serviceOption(Route.Routes).pipe(Effect.andThen(Option.getOrUndefined));
-    const port = yield* Config.number("PORT").pipe(Effect.catchTag("ConfigError", () => {
+import * as Socket from "../Socket.js"
+import * as Bun from "bun"
+import * as Config from "effect/Config"
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
+import * as NOs from "node:os"
+import * as NPath from "node:path"
+import * as PathPattern from "../PathPattern.js"
+import * as PlataformRuntime from "../PlatformRuntime.js"
+import * as Route from "../Route.js"
+import * as RouteHttp from "../RouteHttp.js"
+import * as StartApp from "../StartApp.js"
+import * as RouteTree from "../RouteTree.js"
+import * as BunRoute from "./BunRoute.js"
+
+/**
+ * Basically `Omit<Bun.Serve.Options, "fetch" | "error" | "websocket">`
+ * TypeScript 5.9 cannot verify discriminated union types used in
+ * {@link Bun.serve} so we need to define them explicitly.
+ */
+
+export const BunServer = Context.GenericTag("effect-start/BunServer")
+
+export const make = (
+  options,
+  tree,
+) =>
+  Effect.gen(function* () {
+    const port = yield* Config.number("PORT").pipe(
+      Effect.catchTag("ConfigError", () => {
         return PlataformRuntime.isAgentHarness()
-            ? Effect.succeed(0) // random port
-            : Effect.succeed(3000);
-    }));
-    const hostFlag = process.argv.includes("--host");
-    const hostname = yield* Config.string("HOSTNAME").pipe(Effect.catchTag("ConfigError", () => Effect.succeed(hostFlag ? "0.0.0.0" : undefined)));
+          ? Effect.succeed(0) // random port
+          : Effect.succeed(3000)
+      }),
+    )
+    const hostFlag = process.argv.includes("--host")
+    const hostname = yield* Config.string("HOST").pipe(
+      Effect.catchTag("ConfigError", () => Effect.succeed(hostFlag ? "0.0.0.0" : undefined)),
+    )
+
     const handlerStack = [
-        function (_request, _server) {
-            return new Response("not found", { status: 404 });
-        },
-    ];
+      function (_request, _server) {
+        return new Response("not found", { status: 404 })
+      },
+    ]
+
     const service = BunServer.of({
-        // During the construction we need to create a service imlpementation
-        // first so we can provide it in the runtime that will be used in web
-        // handlers. After we create the runtime, we set it below so it's always
-        // available at runtime.
-        // An alternative approach would be to use Bun.Server.reload but I prefer
-        // to avoid it since it's badly documented and has bunch of bugs.
-        server: undefined,
-        pushHandler(fetch) {
-            handlerStack.push(fetch);
-            reload();
-        },
-        popHandler() {
-            handlerStack.pop();
-            reload();
-        },
-    });
-    const runtime = yield* Effect.runtime().pipe(Effect.andThen(Runtime.provideService(BunServer, service)));
-    let currentRoutes = routes ? yield* walkBunRoutes(runtime, routes) : {};
+      // During the construction we need to create a service imlpementation
+      // first so we can provide it in the runtime that will be used in web
+      // handlers. After we create the runtime, we set it below so it's always
+      // available at runtime.
+      // An alternative approach would be to use Bun.Server.reload but I prefer
+      // to avoid it since it's badly documented and has bunch of bugs.
+      server: undefined,
+      pushHandler(fetch) {
+        handlerStack.push(fetch)
+        reload()
+      },
+      popHandler() {
+        handlerStack.pop()
+        reload()
+      },
+    })
+
+    const runtime = yield* Effect.runtime().pipe(
+      Effect.andThen(Runtime.provideService(BunServer, service)),
+    )
+
+    let currentRoutes = tree ? yield* walkBunRoutes(runtime, tree) : {}
+
     const websocket = {
-        open(ws) {
-            Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws));
-        },
-        message(ws, message) {
-            ws.data.run(message);
-        },
-        close(ws, code, closeReason) {
-            Deferred.unsafeDone(ws.data.closeDeferred, Socket.defaultCloseCodeIsError(code)
-                ? Exit.fail(new Socket.SocketCloseError({
-                    reason: "Close",
-                    code,
-                    closeReason,
-                }))
-                : Exit.void);
-        },
-    };
-    const server = Bun?.serve({
-        port,
-        hostname,
-        ...options,
-        routes: currentRoutes,
-        fetch: handlerStack[0],
-        websocket,
-    });
+      open(ws) {
+        Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws))
+      },
+      message(ws, message) {
+        ws.data.run(message)
+      },
+      close(ws, code, closeReason) {
+        Deferred.unsafeDone(
+          ws.data.closeDeferred,
+          Socket.defaultCloseCodeIsError(code)
+            ? Exit.fail(
+                new Socket.SocketCloseError({
+                  reason: "Close",
+                  code,
+                  closeReason,
+                }),
+              )
+            : Exit.void,
+        )
+      },
+    }
+
+    const server = Bun.serve({
+      port,
+      hostname,
+      ...options,
+      routes: currentRoutes,
+      fetch: handlerStack[0],
+      websocket,
+    })
+
     // @ts-expect-error
-    service.server = server;
-    yield* Effect.addFinalizer(() => Effect.sync(() => {
-        server.stop();
-    }));
+    service.server = server
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        server.stop()
+      }),
+    )
+
     const reload = () => {
-        server.reload({
-            fetch: handlerStack[handlerStack.length - 1],
-            routes: currentRoutes,
-            websocket,
-        });
-    };
+      server.reload({
+        fetch: handlerStack[handlerStack.length - 1],
+        routes: currentRoutes,
+        websocket,
+      })
+    }
+
     const bunServer = BunServer.of({
-        server,
-        pushHandler(fetch) {
-            handlerStack.push(fetch);
-            reload();
-        },
-        popHandler() {
-            handlerStack.pop();
-            reload();
-        },
-    });
-    return bunServer;
-});
+      server,
+      pushHandler(fetch) {
+        handlerStack.push(fetch)
+        reload()
+      },
+      popHandler() {
+        handlerStack.pop()
+        reload()
+      },
+    })
+
+    return bunServer
+  })
+
 /**
  * Provides HttpServer using BunServer under the hood.
  */
-export const layer = (options) => Layer.scoped(BunServer, make(options ?? {}));
-export const withLogAddress = (layer) => Layer.effectDiscard(BunServer.pipe(Effect.andThen((server) => {
-    const { hostname, port } = server.server;
-    const addr = hostname === "0.0.0.0" ? getLocalIp() : "localhost";
-    return Effect.log(`Listening on http://${addr}:${port}`);
-}))).pipe(Layer.provideMerge(layer));
+export const layer = (options) =>
+  Layer.scoped(BunServer, make(options ?? {}))
+
+export const layerRoutes = (
+  options,
+) =>
+  Layer.scoped(
+    BunServer,
+    Effect.gen(function* () {
+      const routes = yield* Route.Routes
+      return yield* make(options ?? {}, routes)
+    }),
+  )
+
+/**
+ * Resolves the Bun server in one place for Start.serve so routes are available:
+ * 1) Reuse a user-provided BunServer when one already exists in context.
+ * 2) Otherwise create the server from Route.Routes when routes are available.
+ * 3) Otherwise create a fallback server with the default 404 handler.
+ */
+export const layerStart = (
+  options,
+) =>
+  Layer.scoped(
+    BunServer,
+    Effect.gen(function* () {
+      const app = yield* StartApp.StartApp
+      const existing = yield* Effect.serviceOption(BunServer)
+      if (Option.isSome(existing)) {
+        yield* Deferred.succeed(app.server, existing.value)
+        return existing.value
+      }
+      const routes = yield* Effect.serviceOption(Route.Routes)
+      if (Option.isSome(routes)) {
+        const server = yield* make(options ?? {}, routes.value)
+        yield* Deferred.succeed(app.server, server)
+        return server
+      }
+      const server = yield* make(options ?? {})
+      yield* Deferred.succeed(app.server, server)
+      return server
+    }),
+  )
+
+export const withLogAddress = (layer) =>
+  Layer.effectDiscard(
+    Effect.gen(function* () {
+      const { server } = yield* BunServer
+      const { hostname, port } = server
+      const addr = hostname === "0.0.0.0" ? getLocalIp() : "localhost"
+
+      yield* Effect.log(`Listening on http://${addr}:${port}`)
+    }),
+  ).pipe(Layer.provideMerge(layer))
+
 function walkBunRoutes(runtime, tree) {
-    return Effect.gen(function* () {
-        const bunRoutes = {};
-        const pathGroups = new Map();
-        const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime);
-        for (const route of RouteTree.walk(tree)) {
-            const bunDescriptors = BunRoute.descriptors(route);
-            if (bunDescriptors) {
-                const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad);
-                if (htmlBundle.files) {
-                    registerPrebuiltBundle(bunDescriptors.bunPrefix, htmlBundle, bunRoutes);
-                }
-                else {
-                    bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle;
-                }
-            }
-            const path = Route.descriptor(route).path;
-            const group = pathGroups.get(path) ?? [];
-            group.push(route);
-            pathGroups.set(path, group);
+  return Effect.gen(function* () {
+    const bunRoutes = {}
+    const pathGroups = new Map()
+    const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime)
+
+    for (const route of RouteTree.walk(tree)) {
+      const bunDescriptors = BunRoute.descriptors(route)
+      if (bunDescriptors) {
+        const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
+        if (htmlBundle.files) {
+          registerPrebuiltBundle(bunDescriptors.bunPrefix, htmlBundle, bunRoutes)
+        } else {
+          bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
         }
-        for (const [path, routes] of pathGroups) {
-            const handler = toWebHandler(routes);
-            for (const bunPath of PathPattern.toBun(path)) {
-                bunRoutes[bunPath] = handler;
-            }
-        }
-        return bunRoutes;
-    });
+      }
+
+      const path = Route.descriptor(route).path
+      const group = pathGroups.get(path) ?? []
+      group.push(route)
+      pathGroups.set(path, group)
+    }
+
+    for (const [path, routes] of pathGroups) {
+      const handler = toWebHandler(routes)
+      for (const bunPath of PathPattern.toBun(path)) {
+        bunRoutes[bunPath] = handler
+      }
+    }
+
+    return bunRoutes
+  })
 }
+
 function registerPrebuiltBundle(prefix, bundle, bunRoutes) {
-    const mainDir = NPath.dirname(Bun.main);
-    const indexPath = NPath.resolve(mainDir, bundle.index);
-    bunRoutes[`${prefix}/*`] = () => new Response(Bun.file(indexPath), { headers: { "content-type": "text/html;charset=utf-8" } });
-    for (const file of bundle.files ?? []) {
-        if (file.loader === "html")
-            continue;
-        const absPath = NPath.resolve(mainDir, file.path);
-        const basename = NPath.basename(file.path);
-        bunRoutes[`/${basename}`] = () => new Response(Bun.file(absPath), { headers: file.headers ?? {} });
-    }
+  const mainDir = NPath.dirname(Bun.main)
+  const indexPath = NPath.resolve(mainDir, bundle.index)
+
+  const htmlPromise = rewriteRelativeAssetPaths(Bun.file(indexPath).text())
+
+  bunRoutes[`${prefix}/*`] = async () =>
+    new Response(await htmlPromise, { headers: { "content-type": "text/html;charset=utf-8" } })
+
+  for (const file of bundle.files ?? []) {
+    if (file.loader === "html") continue
+    const absPath = NPath.resolve(mainDir, file.path)
+    const basename = NPath.basename(file.path)
+    bunRoutes[`/${basename}`] = () =>
+      new Response(Bun.file(absPath), { headers: file.headers ?? {} })
+  }
+}
+
+function rewriteRelativeAssetPaths(html) {
+  const rewriter = new HTMLRewriter()
+    .on("link[href]", {
+      element(el) {
+        const href = el.getAttribute("href")
+        if (href && isRelativePath(href)) {
+          el.setAttribute("href", "/" + assetBasename(href))
+        }
+      },
+    })
+    .on("script[src]", {
+      element(el) {
+        const src = el.getAttribute("src")
+        if (src && isRelativePath(src)) {
+          el.setAttribute("src", "/" + assetBasename(src))
+        }
+      },
+    })
+
+  return Promise.resolve(html).then((h) => rewriter.transform(new Response(h)).text())
+}
+
+function isRelativePath(path) {
+  return path.startsWith("./") || path.startsWith("../")
+}
+
+function assetBasename(path) {
+  const i = path.lastIndexOf("/")
+  return i === -1 ? path : path.slice(i + 1)
 }
+
 function getLocalIp() {
-    return Object.values(NOs.networkInterfaces())
-        .flatMap((addresses) => addresses ?? [])
-        .find((addr) => addr.family === "IPv4" && !addr.internal)?.address;
+  return Object.values(NOs.networkInterfaces())
+    .flatMap((addresses) => addresses ?? [])
+    .find((addr) => addr.family === "IPv4" && !addr.internal)?.address
 }

package/dist/bun/BunVirtualFilesPlugin.js

@@ -1,40 +1,54 @@
+
+
 function loaderFromPath(path) {
-    return path.slice(path.lastIndexOf(".") + 1);
+  return path.slice(path.lastIndexOf(".") + 1)
 }
+
 export function make(files) {
-    return {
-        name: "virtual-fs",
-        setup(build) {
-            build.onResolve({
-                // change the filter so it only works for file namespace
-                filter: /.*/,
-            }, (args) => {
-                const resolved = resolvePath(args.path, args.resolveDir);
-                const resolvedFile = files[resolved];
-                if (resolvedFile) {
-                    return {
-                        path: resolved,
-                        namespace: "virtual-fs",
-                    };
-                }
-                return;
-            });
-            build.onLoad({
-                filter: /.*/,
-                namespace: "virtual-fs",
-            }, (args) => {
-                const contents = files[args.path];
-                if (!contents) {
-                    return undefined;
-                }
-                return {
-                    contents,
-                    loader: loaderFromPath(args.path),
-                };
-            });
+  return {
+    name: "virtual-fs",
+    setup(build) {
+      build.onResolve(
+        {
+          // change the filter so it only works for file namespace
+          filter: /.*/,
         },
-    };
+        (args) => {
+          const resolved = resolvePath(args.path, args.resolveDir)
+          const resolvedFile = files[resolved]
+
+          if (resolvedFile) {
+            return {
+              path: resolved,
+              namespace: "virtual-fs",
+            }
+          }
+          return
+        },
+      )
+
+      build.onLoad(
+        {
+          filter: /.*/,
+          namespace: "virtual-fs",
+        },
+        (args) => {
+          const contents = files[args.path]
+
+          if (!contents) {
+            return undefined
+          }
+
+          return {
+            contents,
+            loader: loaderFromPath(args.path),
+          }
+        },
+      )
+    },
+  }
 }
+
 function resolvePath(path, base = process.cwd()) {
-    return Bun.resolveSync(path, base);
+  return Bun.resolveSync(path, base)
 }