effect-start 0.17.2 → 0.19.0

package/src/hyper/HyperRoute.test.tsx

@@ -1,197 +0,0 @@
-/** @jsxImportSource effect-start */
-import * as test from "bun:test"
-import * as Effect from "effect/Effect"
-import * as Entity from "../Entity.ts"
-import * as Http from "../Http.ts"
-import * as Route from "../Route.ts"
-import * as RouteHttp from "../RouteHttp.ts"
-import * as HyperRoute from "./HyperRoute.ts"
-
-test.describe("HyperRoute.html", () => {
-  test.it("renders JSX to HTML string", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <div>
-            Hello World
-          </div>,
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(response.status).toBe(200)
-    test.expect(response.headers.get("Content-Type")).toBe("text/html; charset=utf-8")
-    test.expect(await response.text()).toBe("<div>Hello World</div>")
-  })
-
-  test.it("renders nested JSX elements", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <div class="container">
-            <h1>
-              Title
-            </h1>
-            <p>
-              Paragraph
-            </p>
-          </div>,
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe(
-      "<div class=\"container\"><h1>Title</h1><p>Paragraph</p></div>",
-    )
-  })
-
-  test.it("renders JSX from Effect", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          Effect.succeed(
-            <span>
-              From Effect
-            </span>,
-          ),
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe("<span>From Effect</span>")
-  })
-
-  test.it("renders JSX from generator function", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          Effect.gen(function*() {
-            const name = yield* Effect.succeed("World")
-            return (
-              <div>
-                Hello {name}
-              </div>
-            )
-          }),
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe("<div>Hello World</div>")
-  })
-
-  test.it("renders JSX from handler function", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html((context) =>
-          Effect.succeed(
-            <div>
-              Request received
-            </div>,
-          )
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe("<div>Request received</div>")
-  })
-
-  test.it("renders JSX with dynamic content", async () => {
-    const items = ["Apple", "Banana", "Cherry"]
-
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <ul>
-            {items.map((item) => (
-              <li>
-                {item}
-              </li>
-            ))}
-          </ul>,
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe(
-      "<ul><li>Apple</li><li>Banana</li><li>Cherry</li></ul>",
-    )
-  })
-
-  test.it("handles Entity with JSX body", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          Entity.make(
-            <div>
-              With Entity
-            </div>,
-            { status: 201 },
-          ),
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(response.status).toBe(201)
-    test.expect(await response.text()).toBe("<div>With Entity</div>")
-  })
-
-  test.it("renders data-* attributes with object values as JSON", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <div
-            data-signals={{
-              draft: "",
-              pendingDraft: "",
-              username: "User123",
-            }}
-          >
-            Content
-          </div>,
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe(
-      "<div data-signals=\"{&quot;draft&quot;:&quot;&quot;,&quot;pendingDraft&quot;:&quot;&quot;,&quot;username&quot;:&quot;User123&quot;}\">Content</div>",
-    )
-  })
-
-  test.it("renders script with function child as IIFE", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <script>
-            {(window) => {
-              console.log("Hello from", window.document.title)
-            }}
-          </script>,
-        ),
-      ),
-    )
-
-    const response = await Http.fetch(handler, { path: "/" })
-    const text = await response.text()
-
-    test.expect(text).toContain("<script>(")
-    test.expect(text).toContain(")(window)</script>")
-    test.expect(text).toContain("window.document.title")
-  })
-})

package/src/middlewares/BasicAuthMiddleware.test.ts

@@ -1,84 +0,0 @@
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as test from "bun:test"
-import * as Effect from "effect/Effect"
-import * as BasicAuthMiddleware from "./BasicAuthMiddleware.js"
-
-const mockApp = Effect.succeed(
-  HttpServerResponse.text("OK", { status: 200 }),
-)
-
-const config: BasicAuthMiddleware.BasicAuthConfig = {
-  username: "admin",
-  password: "secret",
-}
-
-const runWithAuth = (authHeader: string | undefined) => {
-  const middleware = BasicAuthMiddleware.make(config)
-  const wrappedApp = middleware(mockApp)
-
-  const headers: Record<string, string> = {}
-  if (authHeader !== undefined) {
-    headers.authorization = authHeader
-  }
-
-  const mockRequest = HttpServerRequest.fromWeb(
-    new Request("http://localhost/test", { headers }),
-  )
-
-  return wrappedApp.pipe(
-    Effect.provideService(HttpServerRequest.HttpServerRequest, mockRequest),
-    Effect.runPromise,
-  )
-}
-
-test.describe("BasicAuthMiddleware", () => {
-  test.it("returns 401 when no authorization header is present", async () => {
-    const response = await runWithAuth(undefined)
-    test
-      .expect(response.status)
-      .toBe(401)
-    test
-      .expect(response.headers["www-authenticate"])
-      .toBe("Basic")
-  })
-
-  test.it("returns 401 when authorization header does not start with Basic", async () => {
-    const response = await runWithAuth("Bearer token")
-    test
-      .expect(response.status)
-      .toBe(401)
-  })
-
-  test.it("returns 401 when credentials are invalid", async () => {
-    const invalidCredentials = btoa("wrong:credentials")
-    const response = await runWithAuth(`Basic ${invalidCredentials}`)
-    test
-      .expect(response.status)
-      .toBe(401)
-  })
-
-  test.it("returns 401 when username is wrong", async () => {
-    const invalidCredentials = btoa("wronguser:secret")
-    const response = await runWithAuth(`Basic ${invalidCredentials}`)
-    test
-      .expect(response.status)
-      .toBe(401)
-  })
-
-  test.it("returns 401 when password is wrong", async () => {
-    const invalidCredentials = btoa("admin:wrongpassword")
-    const response = await runWithAuth(`Basic ${invalidCredentials}`)
-    test
-      .expect(response.status)
-      .toBe(401)
-  })
-
-  test.it("passes through to app when credentials are valid", async () => {
-    const validCredentials = btoa("admin:secret")
-    const response = await runWithAuth(`Basic ${validCredentials}`)
-    test
-      .expect(response.status)
-      .toBe(200)
-  })
-})

package/src/testing/TestHttpClient.test.ts

@@ -1,83 +0,0 @@
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as test from "bun:test"
-import * as Effect from "effect/Effect"
-import { effectFn } from "./index.ts"
-import * as TestHttpClient from "./TestHttpClient.ts"
-
-const App = Effect.gen(function*() {
-  const req = yield* HttpServerRequest.HttpServerRequest
-
-  if (req.url == "/") {
-    return HttpServerResponse.text("Hello, World!")
-  }
-
-  return HttpServerResponse.text("Not Found", {
-    status: 404,
-  })
-})
-
-const AppClient = TestHttpClient.make(App)
-
-const effect = effectFn()
-
-test.it("ok", () =>
-  effect(function*() {
-    const res = yield* AppClient.get("/")
-
-    test
-      .expect(res.status)
-      .toEqual(200)
-    test
-      .expect(yield* res.text)
-      .toEqual("Hello, World!")
-  }))
-
-test.it("not found", () =>
-  effect(function*() {
-    const res = yield* AppClient.get("/nope")
-
-    test
-      .expect(res.status)
-      .toEqual(404)
-    test
-      .expect(yield* res.text)
-      .toEqual("Not Found")
-  }))
-
-test.describe("FetchHandler", () => {
-  const FetchClient = TestHttpClient.make((req) =>
-    new Response(`Hello from ${req.url}`, { status: 200 })
-  )
-
-  test.it("works with sync handler", () =>
-    effect(function*() {
-      const res = yield* FetchClient.get("/test")
-
-      test
-        .expect(res.status)
-        .toEqual(200)
-      test
-        .expect(yield* res.text)
-        .toContain("/test")
-    }))
-
-  const AsyncFetchClient = TestHttpClient.make(async (req) => {
-    await Promise.resolve()
-    return new Response(`Async: ${req.method} ${new URL(req.url).pathname}`, {
-      status: 201,
-    })
-  })
-
-  test.it("works with async handler", () =>
-    effect(function*() {
-      const res = yield* AsyncFetchClient.post("/async-path")
-
-      test
-        .expect(res.status)
-        .toEqual(201)
-      test
-        .expect(yield* res.text)
-        .toEqual("Async: POST /async-path")
-    }))
-})

package/src/testing/TestLogger.test.ts

@@ -1,51 +0,0 @@
-import * as test from "bun:test"
-import * as Effect from "effect/Effect"
-import * as Ref from "effect/Ref"
-import * as TestLogger from "./TestLogger.ts"
-
-test.it("TestLogger captures log messages", () =>
-  Effect
-    .gen(function*() {
-      const logger = yield* TestLogger.TestLogger
-
-      yield* Effect.logError("This is an error")
-      yield* Effect.logWarning("This is a warning")
-      yield* Effect.logInfo("This is info")
-
-      const messages = yield* Ref.get(logger.messages)
-
-      test
-        .expect(messages)
-        .toHaveLength(3)
-      test
-        .expect(messages[0])
-        .toContain("[Error]")
-      test
-        .expect(messages[0])
-        .toContain("This is an error")
-      test
-        .expect(messages[1])
-        .toContain("[Warning]")
-      test
-        .expect(messages[1])
-        .toContain("This is a warning")
-      test
-        .expect(messages[2])
-        .toContain("[Info]")
-      test
-        .expect(messages[2])
-        .toContain("This is info")
-    })
-    .pipe(Effect.provide(TestLogger.layer()), Effect.runPromise))
-
-test.it("TestLogger starts with empty messages", () =>
-  Effect
-    .gen(function*() {
-      const logger = yield* TestLogger.TestLogger
-      const messages = yield* Ref.get(logger.messages)
-
-      test
-        .expect(messages)
-        .toHaveLength(0)
-    })
-    .pipe(Effect.provide(TestLogger.layer()), Effect.runPromise))

package/src/x/datastar/Datastar.test.ts

@@ -1,266 +0,0 @@
-import * as test from "bun:test"
-import * as HyperHtml from "../../hyper/HyperHtml.ts"
-import * as HyperNode from "../../hyper/HyperNode.ts"
-import { jsx } from "../../hyper/jsx-runtime.ts"
-import * as Datastar from "./Datastar.ts"
-
-test.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)
-
-  test
-    .expect(html)
-    .toBe(
-      "<div data-signals=\"{&quot;foo&quot;:1,&quot;bar&quot;:{&quot;baz&quot;:&quot;hello&quot;}}\"></div>",
-    )
-})
-
-test.it("data-signals string passthrough", () => {
-  const node = HyperNode.make("div", {
-    "data-signals": "$mySignal",
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  test
-    .expect(html)
-    .toBe("<div data-signals=\"$mySignal\"></div>")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toBe(
-      "<div data-signals-user=\"{&quot;name&quot;:&quot;John&quot;,&quot;age&quot;:30}\"></div>",
-    )
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toContain("id=\"test\"")
-  test
-    .expect(html)
-    .toContain("class=\"my-class\"")
-  test
-    .expect(html)
-    .toContain("data-text=\"$count\"")
-  test
-    .expect(html)
-    .toContain("data-signals=\"{&quot;count&quot;:0}\"")
-})
-
-test.it("null and undefined values ignored", () => {
-  const node = HyperNode.make("div", {
-    "data-signals": null,
-    "data-other": undefined,
-  })
-
-  const html = HyperHtml.renderToString(node, Datastar.HyperHooks)
-
-  test
-    .expect(html)
-    .toBe("<div></div>")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toContain("data-signals=")
-  test
-    .expect(html)
-    .toContain("John Doe")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toContain(
-      "data-class=\"{&quot;hidden&quot;:true,&quot;visible&quot;:false}\"",
-    )
-  test
-    .expect(html)
-    .toContain(
-      "data-style=\"{&quot;color&quot;:&quot;red&quot;,&quot;display&quot;:&quot;none&quot;}\"",
-    )
-  test
-    .expect(html)
-    .toContain("data-show=\"true\"")
-  test
-    .expect(html)
-    .toContain("data-text=\"$count\"")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toBe(
-      "<div data-attr=\"{&quot;disabled&quot;:true,&quot;tabindex&quot;:0}\"></div>",
-    )
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .not
-    .toContain("data-ignore=\"")
-  test
-    .expect(html)
-    .toContain("data-ignore-morph")
-  test
-    .expect(html)
-    .not
-    .toContain("data-ignore-morph=")
-})
-
-test.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)
-
-  test
-    .expect(htmlTrue)
-    .toContain("data-ignore")
-  test
-    .expect(htmlTrue)
-    .not
-    .toContain("data-ignore=")
-  test
-    .expect(htmlFalse)
-    .not
-    .toContain("data-ignore")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toContain("data-class-active=\"hidden\"")
-  test
-    .expect(html)
-    .toContain("data-attr-tabindex=\"5\"")
-  test
-    .expect(html)
-    .toContain("data-style-opacity=\"0.5\"")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toBe(
-      "<div data-signals=\"{&quot;isOpen&quot;:false,&quot;count&quot;:42}\">content</div>",
-    )
-  test
-    .expect(html)
-    .not
-    .toContain("[object Object]")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .toBe(
-      "<div data-signals=\"{&quot;isOpen&quot;:false}\"><span>nested content</span></div>",
-    )
-  test
-    .expect(html)
-    .not
-    .toContain("[object Object]")
-})
-
-test.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)
-
-  test
-    .expect(html)
-    .not
-    .toContain("[object Object]")
-})