effect-start 0.9.0 → 0.10.0

package/src/bun/BunRoute_bundles.test.ts

@@ -0,0 +1,218 @@
+import * as Bun from "bun"
+import * as t from "bun:test"
+import * as Effect from "effect/Effect"
+import * as Route from "../Route.ts"
+import type * as Router from "../Router.ts"
+import * as BunRoute from "./BunRoute.ts"
+
+t.describe("BunRoute proxy with Bun.serve", () => {
+  t.test("BunRoute proxy returns same content as direct bundle access", async () => {
+    const bunRoute = BunRoute.loadBundle(() =>
+      import("../../static/TestPage.html")
+    )
+
+    const router: Router.RouterContext = {
+      routes: [
+        {
+          path: "/test",
+          load: () => Promise.resolve({ default: bunRoute }),
+        },
+      ],
+    }
+
+    const routes = await Effect.runPromise(BunRoute.routesFromRouter(router))
+
+    const internalPath = Object.keys(routes).find((k) =>
+      k.includes("~BunRoute-")
+    )
+    t.expect(internalPath).toBeDefined()
+
+    const proxyHandler = routes["/test"]
+    t.expect(typeof proxyHandler).toBe("function")
+
+    const internalBundle = routes[internalPath!]
+    t.expect(internalBundle).toHaveProperty("index")
+
+    const server = Bun.serve({
+      port: 0,
+      routes,
+      fetch: () => new Response("Not found", { status: 404 }),
+    })
+
+    try {
+      const directResponse = await fetch(
+        `http://localhost:${server.port}${internalPath}`,
+      )
+      const proxyResponse = await fetch(`http://localhost:${server.port}/test`)
+
+      t.expect(proxyResponse.status).toBe(directResponse.status)
+
+      const directText = await directResponse.text()
+      const proxyText = await proxyResponse.text()
+
+      t.expect(proxyText).toBe(directText)
+      t.expect(proxyText).toContain("Test Page Content")
+    } finally {
+      server.stop()
+    }
+  })
+
+  t.test("multiple BunRoutes each get unique internal paths", async () => {
+    const bunRoute1 = BunRoute.loadBundle(() =>
+      import("../../static/TestPage.html")
+    )
+    const bunRoute2 = BunRoute.loadBundle(() =>
+      import("../../static/AnotherPage.html")
+    )
+
+    const router: Router.RouterContext = {
+      routes: [
+        {
+          path: "/page1",
+          load: () => Promise.resolve({ default: bunRoute1 }),
+        },
+        {
+          path: "/page2",
+          load: () => Promise.resolve({ default: bunRoute2 }),
+        },
+      ],
+    }
+
+    const routes = await Effect.runPromise(BunRoute.routesFromRouter(router))
+
+    const internalPaths = Object.keys(routes).filter((k) =>
+      k.includes("~BunRoute-")
+    )
+    t.expect(internalPaths).toHaveLength(2)
+
+    const nonces = internalPaths.map((p) => {
+      const match = p.match(/~BunRoute-([a-z0-9]+)$/)
+      return match?.[1]
+    })
+    t.expect(nonces[0]).toBe(nonces[1])
+
+    const server = Bun.serve({
+      port: 0,
+      routes,
+      fetch: () => new Response("Not found", { status: 404 }),
+    })
+
+    try {
+      const response1 = await fetch(`http://localhost:${server.port}/page1`)
+      const response2 = await fetch(`http://localhost:${server.port}/page2`)
+
+      const text1 = await response1.text()
+      const text2 = await response2.text()
+
+      t.expect(text1).toContain("Test Page Content")
+      t.expect(text2).toContain("Another Page Content")
+    } finally {
+      server.stop()
+    }
+  })
+
+  t.test("proxy preserves request headers", async () => {
+    const bunRoute = BunRoute.loadBundle(() =>
+      import("../../static/TestPage.html")
+    )
+
+    const router: Router.RouterContext = {
+      routes: [
+        {
+          path: "/headers-test",
+          load: () => Promise.resolve({ default: bunRoute }),
+        },
+      ],
+    }
+
+    const routes = await Effect.runPromise(BunRoute.routesFromRouter(router))
+
+    const server = Bun.serve({
+      port: 0,
+      routes,
+      fetch: () => new Response("Not found", { status: 404 }),
+    })
+
+    try {
+      const response = await fetch(
+        `http://localhost:${server.port}/headers-test`,
+        {
+          headers: {
+            "Accept": "text/html",
+            "X-Custom-Header": "test-value",
+          },
+        },
+      )
+
+      t.expect(response.status).toBe(200)
+      t.expect(await response.text()).toContain("Test Page Content")
+    } finally {
+      server.stop()
+    }
+  })
+
+  t.test("mixed BunRoute and regular routes work together", async () => {
+    const bunRoute = BunRoute.loadBundle(() =>
+      import("../../static/TestPage.html")
+    )
+    const textRoute = Route.text(Effect.succeed("Hello from text route"))
+
+    const router: Router.RouterContext = {
+      routes: [
+        {
+          path: "/html",
+          load: () => Promise.resolve({ default: bunRoute }),
+        },
+        {
+          path: "/api",
+          load: () => Promise.resolve({ default: textRoute }),
+        },
+      ],
+    }
+
+    const routes = await Effect.runPromise(BunRoute.routesFromRouter(router))
+
+    const server = Bun.serve({
+      port: 0,
+      routes,
+      fetch: () => new Response("Not found", { status: 404 }),
+    })
+
+    try {
+      const htmlResponse = await fetch(`http://localhost:${server.port}/html`)
+      const apiResponse = await fetch(`http://localhost:${server.port}/api`)
+
+      t.expect(await htmlResponse.text()).toContain("Test Page Content")
+      t.expect(await apiResponse.text()).toBe("Hello from text route")
+    } finally {
+      server.stop()
+    }
+  })
+
+  t.test("nonce is different across separate routesFromRouter calls", async () => {
+    const bunRoute = BunRoute.loadBundle(() =>
+      import("../../static/TestPage.html")
+    )
+
+    const router: Router.RouterContext = {
+      routes: [
+        {
+          path: "/test",
+          load: () => Promise.resolve({ default: bunRoute }),
+        },
+      ],
+    }
+
+    const routes1 = await Effect.runPromise(BunRoute.routesFromRouter(router))
+    const routes2 = await Effect.runPromise(BunRoute.routesFromRouter(router))
+
+    const internalPath1 = Object.keys(routes1).find((k) =>
+      k.includes("~BunRoute-")
+    )
+    const internalPath2 = Object.keys(routes2).find((k) =>
+      k.includes("~BunRoute-")
+    )
+
+    t.expect(internalPath1).not.toBe(internalPath2)
+  })
+})

package/src/bun/BunRuntime.ts

@@ -0,0 +1,33 @@
+import { makeRunMain } from "@effect/platform/Runtime"
+import { constVoid } from "effect/Function"
+
+export const runMain = makeRunMain(({
+  fiber,
+  teardown,
+}) => {
+  const keepAlive = setInterval(constVoid, 2 ** 31 - 1)
+  let receivedSignal = false
+
+  fiber.addObserver((exit) => {
+    if (!receivedSignal) {
+      process.removeListener("SIGINT", onSigint)
+      process.removeListener("SIGTERM", onSigint)
+    }
+    clearInterval(keepAlive)
+    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)
+})

package/src/bun/BunTailwindPlugin.test.ts

@@ -17,7 +17,7 @@ function extractClassNamesBroad(source: string): Set<string> {
   )
 }
 
-t.describe("extractClassNames", () => {
+t.describe(`${extractClassNames.name}`, () => {
   t.test("Basic HTML class attributes", () => {
     const source = `<div class="bg-red-500 text-white">Hello</div>`
     const result = extractClassNames(source)

package/src/bun/_empty.html

@@ -0,0 +1 @@
+

package/src/bun/index.ts

@@ -1,4 +1,5 @@
 export * as BunBundle from "./BunBundle.ts"
-export * as BunFullstackServer from "./BunFullstackServer.ts"
+export * as BunHttpServer from "./BunHttpServer.ts"
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
+export * as BunRoute from "./BunRoute.ts"
 export * as BunTailwindPlugin from "./BunTailwindPlugin.ts"

package/src/testing.ts

@@ -39,12 +39,21 @@ export const effectFn = <RL>(layer?: Layer.Layer<RL, any>) =>
  * some tools, like effect-start, use it to generate temporary
  * files that are then loaded into a runtime.
  */
-const clearStackTraces = (err: any | Error) => {
+const clearStackTraces = (err: unknown) => {
   const ExternalStackTraceLineRegexp = /\(.*\/node_modules\/[^\.]/
 
-  const newErr = new Error(err.message)
-  const stack: string = err.stack ?? ""
+  const message = err instanceof Error
+    ? err.message
+    : typeof err === "object" && err !== null && "message" in err
+    ? String(err.message)
+    : String(err)
+  const stack: string = err instanceof Error
+    ? err.stack ?? ""
+    : typeof err === "object" && err !== null && "stack" in err
+    ? String(err.stack)
+    : ""
 
+  const newErr = new Error(message)
   newErr.stack = Function.pipe(
     stack.split("\n"),
     Array.takeWhile(s => !ExternalStackTraceLineRegexp.test(s)),

package/src/Datastar.test.ts

@@ -1,267 +0,0 @@
-import * as t from "bun:test"
-import * as Datastar from "./Datastar.ts"
-import * as HyperHtml from "./HyperHtml.ts"
-import * as HyperNode from "./HyperNode.ts"
-import { jsx } from "./jsx-runtime.ts"
-
-t.it("data-signals object serialization", () => {
-  const node = HyperNode.make("div", {
-    "data-signals": { foo: 1, bar: { baz: "hello" } } as any,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toBe(
-      "<div data-signals=\"{&quot;foo&quot;:1,&quot;bar&quot;:{&quot;baz&quot;:&quot;hello&quot;}}\"></div>",
-    )
-})
-
-t.it("data-signals string passthrough", () => {
-  const node = HyperNode.make("div", {
-    "data-signals": "$mySignal",
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toBe("<div data-signals=\"$mySignal\"></div>")
-})
-
-t.it("data-signals-* object serialization", () => {
-  const node = HyperNode.make("div", {
-    "data-signals-user": { name: "John", age: 30 } as any,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toBe(
-      "<div data-signals-user=\"{&quot;name&quot;:&quot;John&quot;,&quot;age&quot;:30}\"></div>",
-    )
-})
-
-t.it("non-data attributes unchanged", () => {
-  const node = HyperNode.make("div", {
-    id: "test",
-    class: "my-class",
-    "data-text": "$count",
-    "data-signals": { count: 0 } as any,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toContain("id=\"test\"")
-  t
-    .expect(html)
-    .toContain("class=\"my-class\"")
-  t
-    .expect(html)
-    .toContain("data-text=\"$count\"")
-  t
-    .expect(html)
-    .toContain("data-signals=\"{&quot;count&quot;:0}\"")
-})
-
-t.it("null and undefined values ignored", () => {
-  const node = HyperNode.make("div", {
-    "data-signals": null,
-    "data-other": undefined,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toBe("<div></div>")
-})
-
-t.it("complex nested objects serialization", () => {
-  const complexObject = {
-    user: { name: "John Doe", preferences: { theme: "dark" } },
-    items: [1, 2, 3],
-  }
-
-  const node = HyperNode.make("div", {
-    "data-signals": complexObject as any,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toContain("data-signals=")
-  t
-    .expect(html)
-    .toContain("John Doe")
-})
-
-t.it("non-signals data attributes serialized", () => {
-  const node = HyperNode.make("div", {
-    "data-class": { hidden: true, visible: false } as any,
-    "data-style": { color: "red", display: "none" } as any,
-    "data-show": true as any,
-    "data-text": "$count",
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toContain(
-      "data-class=\"{&quot;hidden&quot;:true,&quot;visible&quot;:false}\"",
-    )
-  t
-    .expect(html)
-    .toContain(
-      "data-style=\"{&quot;color&quot;:&quot;red&quot;,&quot;display&quot;:&quot;none&quot;}\"",
-    )
-  t
-    .expect(html)
-    .toContain("data-show=\"true\"")
-  t
-    .expect(html)
-    .toContain("data-text=\"$count\"")
-})
-
-t.it("data-attr object serialization", () => {
-  const node = HyperNode.make("div", {
-    "data-attr": { disabled: true, tabindex: 0 } as any,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toBe(
-      "<div data-attr=\"{&quot;disabled&quot;:true,&quot;tabindex&quot;:0}\"></div>",
-    )
-})
-
-t.it("boolean attributes converted to strings", () => {
-  const node = HyperNode.make("div", {
-    "data-ignore": false as any,
-    "data-ignore-morph": true as any,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .not
-    .toContain("data-ignore=\"")
-  t
-    .expect(html)
-    .toContain("data-ignore-morph")
-  t
-    .expect(html)
-    .not
-    .toContain("data-ignore-morph=")
-})
-
-t.it("data-ignore attributes only present when true", () => {
-  const nodeTrue = HyperNode.make("div", {
-    "data-ignore": true as any,
-  })
-
-  const nodeFalse = HyperNode.make("div", {
-    "data-ignore": false as any,
-  })
-
-  const htmlTrue = HyperHtml.renderToString(nodeTrue, Datastar.HyperHooks)
-  const htmlFalse = HyperHtml.renderToString(nodeFalse, Datastar.HyperHooks)
-
-  t
-    .expect(htmlTrue)
-    .toContain("data-ignore")
-  t
-    .expect(htmlTrue)
-    .not
-    .toContain("data-ignore=")
-  t
-    .expect(htmlFalse)
-    .not
-    .toContain("data-ignore")
-})
-
-t.it("dynamic attributes with suffixes", () => {
-  const node = HyperNode.make("div", {
-    "data-class-active": "hidden" as any,
-    "data-attr-tabindex": "5" as any,
-    "data-style-opacity": "0.5" as any,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toContain("data-class-active=\"hidden\"")
-  t
-    .expect(html)
-    .toContain("data-attr-tabindex=\"5\"")
-  t
-    .expect(html)
-    .toContain("data-style-opacity=\"0.5\"")
-})
-
-t.it("JSX with data-signals object", () => {
-  const node = jsx("div", {
-    "data-signals": { isOpen: false, count: 42 } as any,
-    children: "content",
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toBe(
-      "<div data-signals=\"{&quot;isOpen&quot;:false,&quot;count&quot;:42}\">content</div>",
-    )
-  t
-    .expect(html)
-    .not
-    .toContain("[object Object]")
-})
-
-t.it("JSX component returning element with data-signals", () => {
-  function TestComponent() {
-    return jsx("div", {
-      "data-signals": { isOpen: false } as any,
-      children: jsx("span", { children: "nested content" }),
-    })
-  }
-
-  const node = jsx(TestComponent, {})
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  t
-    .expect(html)
-    .toBe(
-      "<div data-signals=\"{&quot;isOpen&quot;:false}\"><span>nested content</span></div>",
-    )
-  t
-    .expect(html)
-    .not
-    .toContain("[object Object]")
-})
-
-t.it("debug hook execution", () => {
-  const node = jsx("div", {
-    "data-signals": { isOpen: false, count: 42 } as any,
-    children: "content",
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-  console.log("Final HTML:", html)
-
-  t
-    .expect(html)
-    .not
-    .toContain("[object Object]")
-})

package/src/Datastar.ts

@@ -1,68 +0,0 @@
-import * as HyperNode from "./HyperNode.ts"
-
-export const HyperHooks = {
-  onNode,
-} as const
-
-function onNode(node: HyperNode.HyperNode) {
-  const {
-    "data-signals": dataSignals,
-    "data-class": dataClass,
-    "data-attr": dataAttr,
-    "data-style": dataStyle,
-    "data-show": dataShow,
-    "data-ignore": dataIgnore,
-    "data-ignore-morph": dataIgnoreMorph,
-  } = node.props as any
-
-  if (typeof dataSignals === "object" && dataSignals !== null) {
-    node.props["data-signals"] = JSON.stringify(dataSignals)
-  }
-
-  if (typeof dataClass === "function") {
-    node.props["data-class"] = `(${dataClass.toString()})()`
-  } else if (typeof dataClass === "object" && dataClass !== null) {
-    node.props["data-class"] = JSON.stringify(dataClass)
-  }
-
-  if (typeof dataAttr === "object" && dataAttr !== null) {
-    node.props["data-attr"] = JSON.stringify(dataAttr)
-  }
-
-  if (typeof dataStyle === "function") {
-    node.props["data-style"] = `(${dataStyle.toString()})()`
-  } else if (typeof dataStyle === "object" && dataStyle !== null) {
-    node.props["data-style"] = JSON.stringify(dataStyle)
-  }
-
-  if (typeof dataShow === "boolean") {
-    node.props["data-show"] = dataShow.toString()
-  }
-
-  if (dataIgnore !== true && dataIgnore !== undefined) {
-    delete node.props["data-ignore"]
-  }
-
-  if (dataIgnoreMorph !== true && dataIgnoreMorph !== undefined) {
-    delete node.props["data-ignore-morph"]
-  }
-
-  // Handle dynamic attributes with suffixes
-  for (const [key, value] of Object.entries(node.props)) {
-    if (
-      key.startsWith("data-signals-")
-      && typeof value === "object"
-      && value !== null
-    ) {
-      node.props[key] = JSON.stringify(value)
-    }
-
-    if (
-      key.startsWith("data-on-")
-      && typeof value === "function"
-    ) {
-      // @ts-ignore
-      node.props[key] = `(${value.toString()})()`
-    }
-  }
-}

package/src/bun/BunFullstackServer.ts

@@ -1,45 +0,0 @@
-import { BunHttpServer } from "@effect/platform-bun"
-import * as Config from "effect/Config"
-import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as httpServer from "./BunFullstackServer_httpServer.ts"
-
-// As of Bun v1.2.13, these types are not publicy exported.
-type BunServeFuntionOptions = Parameters<
-  typeof Bun.serve<any, {}>
->[0]
-
-type DefaultOptions = Parameters<typeof BunHttpServer.make>[0]
-
-type Options =
-  & DefaultOptions
-  & Omit<BunServeFuntionOptions, "fetch" | "error">
-
-export const make = (opts: Options) => {
-  return Effect.gen(function*() {
-    const env = yield* Config
-      .string("NODE_ENV")
-      .pipe(Config.option)
-
-    return httpServer.make({
-      development: Option.getOrNull(env) === "development",
-      ...opts,
-    })
-  })
-}
-
-export const layer = (opts: Options) => {
-  return Layer.unwrapEffect(
-    Effect.gen(function*() {
-      const env = yield* Config.string("NODE_ENV").pipe(Config.option)
-      const development = Option.getOrNull(env) !== "development"
-
-      return httpServer.layer({
-        development,
-        ...opts,
-      })
-    }),
-  )
-}