effect-start 0.23.0 → 0.25.0

package/dist/bun/BunImportTrackerPlugin.js

@@ -1,69 +1,91 @@
-import * as NPath from "node:path";
+import * as NPath from "node:path"
+
 /**
  * Tracks all imported modules.
  * State can be accessed via 'virtual:import-tracker' module within a bundle
  * or through `state` property returned by this function.
  */
-export const make = (opts = {}) => {
-    const foundImports = new Map();
-    const baseDir = opts.baseDir ?? process.cwd();
-    return {
-        name: "import tracker",
-        setup(build) {
-            const transpiler = new Bun.Transpiler({
-                loader: "tsx",
-            });
-            // Each module that goes through this onLoad callback
-            // will record its imports in `trackedImports`
-            build.onLoad({
-                filter: /\.(ts|js)x?$/,
-            }, async (args) => {
-                if (!opts.includeNodeModules && args.path.includes("/node_modules/")) {
-                    return undefined;
-                }
-                const contents = await Bun.file(args.path).arrayBuffer();
-                try {
-                    const fileImport = transpiler.scanImports(contents);
-                    const resolvedImports = fileImport.map((imp) => {
-                        const absoluteImportPath = NPath.resolve(NPath.dirname(args.path), 
-                        // 'file' is a default namespace, trim it
-                        imp.path.replace(/^file:/, ""));
-                        return {
-                            ...imp,
-                            // keep all module identifiers with namespace intact
-                            path: /(\w+):/.test(imp.path)
-                                ? imp.path
-                                : NPath.relative(baseDir, absoluteImportPath),
-                        };
-                    });
-                    foundImports.set(NPath.relative(baseDir, args.path), resolvedImports);
-                }
-                catch (e) { }
-                return undefined;
-            });
-            build.onResolve({
-                filter: /^virtual:import-tracker$/,
-            }, () => {
-                return {
-                    namespace: "effect-start",
-                    path: "virtual:import-tracker",
-                };
-            });
-            build.onLoad({
-                filter: /^virtual:import-tracker$/,
-                namespace: "effect-start",
-            }, async (args) => {
-                // Wait for all files to be loaded, ensuring
-                // that every file goes through the above `onLoad()` function
-                // and their imports tracked
-                await args.defer();
-                // Emit JSON containing the stats of each import
-                return {
-                    contents: JSON.stringify(Object.fromEntries(foundImports.entries())),
-                    loader: "json",
-                };
-            });
+export const make = (
+  opts = {},
+) => {
+  const foundImports = new Map()
+  const baseDir = opts.baseDir ?? process.cwd()
+
+  return {
+    name: "import tracker",
+    setup(build) {
+      const transpiler = new Bun.Transpiler({
+        loader: "tsx",
+      })
+
+      // Each module that goes through this onLoad callback
+      // will record its imports in `trackedImports`
+      build.onLoad(
+        {
+          filter: /\.(ts|js)x?$/,
         },
-        state: foundImports,
-    };
-};
+        async (args) => {
+          if (!opts.includeNodeModules && args.path.includes("/node_modules/")) {
+            return undefined
+          }
+
+          const contents = await Bun.file(args.path).arrayBuffer()
+          try {
+            const fileImport = transpiler.scanImports(contents)
+            const resolvedImports = fileImport.map((imp) => {
+              const absoluteImportPath = NPath.resolve(
+                NPath.dirname(args.path),
+                // 'file' is a default namespace, trim it
+                imp.path.replace(/^file:/, ""),
+              )
+
+              return {
+                ...imp,
+                // keep all module identifiers with namespace intact
+                path: /(\w+):/.test(imp.path)
+                  ? imp.path
+                  : NPath.relative(baseDir, absoluteImportPath),
+              }
+            })
+            foundImports.set(NPath.relative(baseDir, args.path), resolvedImports)
+          } catch (e) {}
+
+          return undefined
+        },
+      )
+
+      build.onResolve(
+        {
+          filter: /^virtual:import-tracker$/,
+        },
+        () => {
+          return {
+            namespace: "effect-start",
+            path: "virtual:import-tracker",
+          }
+        },
+      )
+
+      build.onLoad(
+        {
+          filter: /^virtual:import-tracker$/,
+          namespace: "effect-start",
+        },
+        async (args) => {
+          // Wait for all files to be loaded, ensuring
+          // that every file goes through the above `onLoad()` function
+          // and their imports tracked
+          await args.defer()
+
+          // Emit JSON containing the stats of each import
+          return {
+            contents: JSON.stringify(Object.fromEntries(foundImports.entries())),
+            loader: "json",
+          }
+        },
+      )
+    },
+
+    state: foundImports,
+  }
+}

package/dist/bun/BunRoute.js

@@ -1,91 +1,118 @@
-import * as Array from "effect/Array";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Entity from "../Entity.js";
-import * as FilePathPattern from "../FilePathPattern.js";
-import * as Hyper from "../hyper/Hyper.js";
-import * as HyperHtml from "../hyper/HyperHtml.js";
-import * as Route from "../Route.js";
-import * as Unique from "../Unique.js";
-import * as BunServer from "./BunServer.js";
-const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch";
-export class BunRouteError extends Data.TaggedError("BunRouteError") {
-}
-export function descriptors(route) {
-    const descriptor = Route.descriptor(route);
-    if (typeof descriptor.bunPrefix === "string" && typeof descriptor.bunLoad === "function") {
-        return descriptor;
-    }
-    return undefined;
+import * as Array from "effect/Array"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Entity from "../Entity.js"
+import * as FilePathPattern from "../FilePathPattern.js"
+import * as Hyper from "../hyper/Hyper.js"
+import * as HyperHtml from "../hyper/HyperHtml.js"
+import * as Route from "../Route.js"
+import * as Unique from "../Unique.js"
+import * as BunServer from "./BunServer.js"
+
+const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch"
+
+export class BunRouteError extends Data.TaggedError("BunRouteError") {}
+
+export function descriptors(
+  route,
+) {
+  const descriptor = Route.descriptor(route)
+  if (typeof descriptor.bunPrefix === "string" && typeof descriptor.bunLoad === "function") {
+    return descriptor
+  }
+  return undefined
 }
+
 export function htmlBundle(load) {
-    const bunPrefix = `/.BunRoute-${Unique.token(10)}`;
-    const bunLoad = () => Promise.resolve(load()).then((mod) => ("default" in mod ? mod.default : mod));
-    const descriptors = { bunPrefix, bunLoad, format: "html" };
-    return function (self) {
-        const handler = (context, next) => Effect.gen(function* () {
-            const originalRequest = context.request;
-            if (originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true") {
-                const url = new URL(originalRequest.url);
-                return yield* Effect.fail(new BunRouteError({
-                    reason: "ProxyError",
-                    pattern: url.pathname,
-                    message: "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
-                }));
-            }
-            const bunServer = yield* BunServer.BunServer;
-            const url = new URL(originalRequest.url);
-            const internalPath = `${bunPrefix}${url.pathname}`;
-            const internalUrl = new URL(internalPath, bunServer.server.url);
-            const headers = new Headers(originalRequest.headers);
-            headers.set(INTERNAL_FETCH_HEADER, "true");
-            const proxyRequest = new Request(internalUrl, {
-                method: originalRequest.method,
-                headers,
-            });
-            const response = yield* Effect.tryPromise({
-                try: () => fetch(proxyRequest),
-                catch: (error) => new BunRouteError({
-                    reason: "ProxyError",
-                    pattern: internalPath,
-                    message: `Failed to fetch internal HTML bundle: ${String(error)}`,
-                }),
-            });
-            let html = yield* Effect.tryPromise({
-                try: () => response.text(),
-                catch: (error) => new BunRouteError({
-                    reason: "ProxyError",
-                    pattern: internalPath,
-                    message: String(error),
-                }),
-            });
-            const childEntity = yield* Entity.resolve(next(context));
-            const children = childEntity?.body ?? childEntity;
-            let childrenHtml = "";
-            if (children != null) {
-                if (children instanceof Response) {
-                    childrenHtml = yield* Effect.promise(() => children.text());
-                }
-                else if (Hyper.isGenericJsxObject(children)) {
-                    childrenHtml = HyperHtml.renderToString(children);
-                }
-                else {
-                    childrenHtml = String(children);
-                }
-            }
-            html = html.replace(/%children%/g, childrenHtml);
-            return Entity.make(html, {
-                status: response.status,
-                headers: {
-                    "content-type": response.headers.get("content-type"),
-                },
-            });
-        });
-        const route = Route.make(handler, descriptors);
-        return Route.set([...Route.items(self), route], Route.descriptor(self));
-    };
+  const bunPrefix = `/.BunRoute-${Unique.token(10)}`
+  const bunLoad = () =>
+    Promise.resolve(load()).then((mod) => ("default" in mod ? mod.default : mod))
+  const descriptors = { bunPrefix, bunLoad, format: /** @type {const} */ "html" }
+
+  return function (
+    self,
+  ) {
+    const handler = (context, next) =>
+      Effect.gen(function* () {
+        const originalRequest = context.request
+
+        if (originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true") {
+          const url = new URL(originalRequest.url)
+          return yield* Effect.fail(
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: url.pathname,
+              message:
+                "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
+            }),
+          )
+        }
+
+        const bunServer = yield* BunServer.BunServer
+        const url = new URL(originalRequest.url)
+
+        const internalPath = `${bunPrefix}${url.pathname}`
+        const internalUrl = new URL(internalPath, bunServer.server.url)
+
+        const headers = new Headers(originalRequest.headers)
+        headers.set(INTERNAL_FETCH_HEADER, "true")
+
+        const proxyRequest = new Request(internalUrl, {
+          method: originalRequest.method,
+          headers,
+        })
+
+        const response = yield* Effect.tryPromise({
+          try: () => fetch(proxyRequest),
+          catch: (error) =>
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: internalPath,
+              message: `Failed to fetch internal HTML bundle: ${String(error)}`,
+            }),
+        })
+
+        let html = yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (error) =>
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: internalPath,
+              message: String(error),
+            }),
+        })
+
+        const childEntity = yield* Entity.resolve(next(context))
+        const children = childEntity?.body ?? childEntity
+
+        let childrenHtml = ""
+        if (children != null) {
+          if ((children) instanceof Response) {
+            childrenHtml = yield* Effect.promise(() => (children).text())
+          } else if (Hyper.isGenericJsxObject(children)) {
+            childrenHtml = HyperHtml.renderToString(children)
+          } else {
+            childrenHtml = String(children)
+          }
+        }
+
+        html = html.replace(/%children%/g, childrenHtml)
+
+        return Entity.make(html, {
+          status: response.status,
+          headers: {
+            "content-type": response.headers.get("content-type"),
+          },
+        })
+      })
+
+    const route = Route.make(handler, descriptors)
+
+    return Route.set([...Route.items(self), route], Route.descriptor(self))
+  }
 }
+
 /**
  * Validates that a route pattern can be implemented with Bun.serve routes.
  *
@@ -102,20 +129,29 @@ export function htmlBundle(load) {
  * - /[id]~test - Suffix with tilde
  * - /hello-*   - Inline prefix wildcard
  */
+
 export function validateBunPattern(pattern) {
-    const segs = FilePathPattern.segments(pattern);
-    const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment");
-    if (Option.isSome(invalid)) {
-        return Option.some(new BunRouteError({
-            reason: "UnsupportedPattern",
-            pattern,
-            message: `Pattern "${pattern}" contains invalid segment.`,
-        }));
-    }
-    return Option.none();
+  const segs = FilePathPattern.segments(pattern)
+
+  const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment")
+
+  if (Option.isSome(invalid)) {
+    return Option.some(
+      new BunRouteError({
+        reason: "UnsupportedPattern",
+        pattern,
+        message: `Pattern "${pattern}" contains invalid segment.`,
+      }),
+    )
+  }
+
+  return Option.none()
 }
+
 export const isHtmlBundle = (handle) => {
-    return (typeof handle === "object" &&
-        handle !== null &&
-        (handle.toString() === "[object HTMLBundle]" || typeof handle.index === "string"));
-};
+  return (
+    typeof handle === "object" &&
+    handle !== null &&
+    (handle.toString() === "[object HTMLBundle]" || typeof handle.index === "string")
+  )
+}

package/dist/bun/BunRuntime.js

@@ -1,31 +1,41 @@
-import * as GlobalValue from "effect/GlobalValue";
-import * as MutableRef from "effect/MutableRef";
-import * as PlatformRuntime from "../PlatformRuntime.js";
-const mainFiber = GlobalValue.globalValue(Symbol.for("effect-start/BunRuntime/existingFiber"), () => MutableRef.make(undefined));
+import * as GlobalValue from "effect/GlobalValue"
+import * as MutableRef from "effect/MutableRef"
+import * as PlatformRuntime from "../PlatformRuntime.js"
+
+const mainFiber = GlobalValue.globalValue(Symbol.for("effect-start/BunRuntime/existingFiber"), () =>
+  MutableRef.make(undefined),
+)
+
 export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown }) => {
-    const prevFiber = MutableRef.get(mainFiber);
-    MutableRef.set(mainFiber, fiber);
-    let receivedSignal = false;
-    fiber.addObserver((exit) => {
-        if (!receivedSignal) {
-            process.removeListener("SIGINT", onSigint);
-            process.removeListener("SIGTERM", onSigint);
-        }
-        teardown(exit, (code) => {
-            if (receivedSignal || code !== 0) {
-                process.exit(code);
-            }
-        });
-    });
-    function onSigint() {
-        receivedSignal = true;
-        process.removeListener("SIGINT", onSigint);
-        process.removeListener("SIGTERM", onSigint);
-        fiber.unsafeInterruptAsFork(fiber.id());
+  const prevFiber = MutableRef.get(mainFiber)
+
+  MutableRef.set(mainFiber, fiber)
+
+  let receivedSignal = false
+
+  fiber.addObserver((exit) => {
+    if (!receivedSignal) {
+      process.removeListener("SIGINT", onSigint)
+      process.removeListener("SIGTERM", onSigint)
     }
-    process.on("SIGINT", onSigint);
-    process.on("SIGTERM", onSigint);
-    if (prevFiber) {
-        prevFiber.unsafeInterruptAsFork(prevFiber.id());
-    }
-});
+    teardown(exit, (code) => {
+      if (receivedSignal || code !== 0) {
+        process.exit(code)
+      }
+    })
+  })
+
+  function onSigint() {
+    receivedSignal = true
+    process.removeListener("SIGINT", onSigint)
+    process.removeListener("SIGTERM", onSigint)
+    fiber.unsafeInterruptAsFork(fiber.id())
+  }
+
+  process.on("SIGINT", onSigint)
+  process.on("SIGTERM", onSigint)
+
+  if (prevFiber) {
+    prevFiber.unsafeInterruptAsFork(prevFiber.id())
+  }
+})