effect-start 0.14.0 → 0.16.0

package/src/middlewares/BasicAuthMiddleware.test.ts

@@ -1,10 +1,6 @@
 import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
 import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import {
-  describe,
-  expect,
-  it,
-} from "bun:test"
+import * as test from "bun:test"
 import * as Effect from "effect/Effect"
 import * as BasicAuthMiddleware from "./BasicAuthMiddleware.js"
 
@@ -36,39 +32,53 @@ const runWithAuth = (authHeader: string | undefined) => {
   )
 }
 
-describe("BasicAuthMiddleware", () => {
-  it("returns 401 when no authorization header is present", async () => {
+test.describe("BasicAuthMiddleware", () => {
+  test.it("returns 401 when no authorization header is present", async () => {
     const response = await runWithAuth(undefined)
-    expect(response.status).toBe(401)
-    expect(response.headers["www-authenticate"]).toBe("Basic")
+    test
+      .expect(response.status)
+      .toBe(401)
+    test
+      .expect(response.headers["www-authenticate"])
+      .toBe("Basic")
   })
 
-  it("returns 401 when authorization header does not start with Basic", async () => {
+  test.it("returns 401 when authorization header does not start with Basic", async () => {
     const response = await runWithAuth("Bearer token")
-    expect(response.status).toBe(401)
+    test
+      .expect(response.status)
+      .toBe(401)
   })
 
-  it("returns 401 when credentials are invalid", async () => {
+  test.it("returns 401 when credentials are invalid", async () => {
     const invalidCredentials = btoa("wrong:credentials")
     const response = await runWithAuth(`Basic ${invalidCredentials}`)
-    expect(response.status).toBe(401)
+    test
+      .expect(response.status)
+      .toBe(401)
   })
 
-  it("returns 401 when username is wrong", async () => {
+  test.it("returns 401 when username is wrong", async () => {
     const invalidCredentials = btoa("wronguser:secret")
     const response = await runWithAuth(`Basic ${invalidCredentials}`)
-    expect(response.status).toBe(401)
+    test
+      .expect(response.status)
+      .toBe(401)
   })
 
-  it("returns 401 when password is wrong", async () => {
+  test.it("returns 401 when password is wrong", async () => {
     const invalidCredentials = btoa("admin:wrongpassword")
     const response = await runWithAuth(`Basic ${invalidCredentials}`)
-    expect(response.status).toBe(401)
+    test
+      .expect(response.status)
+      .toBe(401)
   })
 
-  it("passes through to app when credentials are valid", async () => {
+  test.it("passes through to app when credentials are valid", async () => {
     const validCredentials = btoa("admin:secret")
     const response = await runWithAuth(`Basic ${validCredentials}`)
-    expect(response.status).toBe(200)
+    test
+      .expect(response.status)
+      .toBe(200)
   })
 })

package/src/{NodeFileSystem.ts → node/FileSystem.ts}

@@ -243,15 +243,19 @@ const makeFile = (() => {
 
   class FileImpl implements FileSystem.File {
     readonly [FileSystem.FileTypeId]: FileSystem.FileTypeId
+    readonly fd: FileSystem.File.Descriptor
+    private readonly append: boolean
 
     private readonly semaphore = Effect.unsafeMakeSemaphore(1)
     private position: bigint = 0n
 
     constructor(
-      readonly fd: FileSystem.File.Descriptor,
-      private readonly append: boolean,
+      fd: FileSystem.File.Descriptor,
+      append: boolean,
     ) {
       this[FileSystem.FileTypeId] = FileSystem.FileTypeId
+      this.fd = fd
+      this.append = append
     }
 
     get stat() {

package/src/testing/TestHttpClient.test.ts

@@ -1,6 +1,6 @@
 import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
 import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as Effect from "effect/Effect"
 import { effectFn } from "./index.ts"
 import * as TestHttpClient from "./TestHttpClient.ts"
@@ -21,49 +21,45 @@ const AppClient = TestHttpClient.make(App)
 
 const effect = effectFn()
 
-t.it("ok", () =>
+test.it("ok", () =>
   effect(function*() {
     const res = yield* AppClient.get("/")
 
-    t
-      .expect(
-        res.status,
-      )
+    test
+      .expect(res.status)
       .toEqual(200)
-    t
-      .expect(
-        yield* res.text,
-      )
+    test
+      .expect(yield* res.text)
       .toEqual("Hello, World!")
   }))
 
-t.it("not found", () =>
+test.it("not found", () =>
   effect(function*() {
     const res = yield* AppClient.get("/nope")
 
-    t
-      .expect(
-        res.status,
-      )
+    test
+      .expect(res.status)
       .toEqual(404)
-    t
-      .expect(
-        yield* res.text,
-      )
+    test
+      .expect(yield* res.text)
       .toEqual("Not Found")
   }))
 
-t.describe("FetchHandler", () => {
+test.describe("FetchHandler", () => {
   const FetchClient = TestHttpClient.make((req) =>
     new Response(`Hello from ${req.url}`, { status: 200 })
   )
 
-  t.it("works with sync handler", () =>
+  test.it("works with sync handler", () =>
     effect(function*() {
       const res = yield* FetchClient.get("/test")
 
-      t.expect(res.status).toEqual(200)
-      t.expect(yield* res.text).toContain("/test")
+      test
+        .expect(res.status)
+        .toEqual(200)
+      test
+        .expect(yield* res.text)
+        .toContain("/test")
     }))
 
   const AsyncFetchClient = TestHttpClient.make(async (req) => {
@@ -73,11 +69,15 @@ t.describe("FetchHandler", () => {
     })
   })
 
-  t.it("works with async handler", () =>
+  test.it("works with async handler", () =>
     effect(function*() {
       const res = yield* AsyncFetchClient.post("/async-path")
 
-      t.expect(res.status).toEqual(201)
-      t.expect(yield* res.text).toEqual("Async: 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,38 +1,51 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as Effect from "effect/Effect"
-import * as Logger from "effect/Logger"
 import * as Ref from "effect/Ref"
 import * as TestLogger from "./TestLogger.ts"
 
-t.it("TestLogger captures log messages", () =>
+test.it("TestLogger captures log messages", () =>
   Effect
     .gen(function*() {
       const logger = yield* TestLogger.TestLogger
 
-      // Log some messages
       yield* Effect.logError("This is an error")
       yield* Effect.logWarning("This is a warning")
       yield* Effect.logInfo("This is info")
 
-      // Read captured messages
       const messages = yield* Ref.get(logger.messages)
 
-      t.expect(messages).toHaveLength(3)
-      t.expect(messages[0]).toContain("[Error]")
-      t.expect(messages[0]).toContain("This is an error")
-      t.expect(messages[1]).toContain("[Warning]")
-      t.expect(messages[1]).toContain("This is a warning")
-      t.expect(messages[2]).toContain("[Info]")
-      t.expect(messages[2]).toContain("This is info")
+      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))
 
-t.it("TestLogger starts with empty messages", () =>
+test.it("TestLogger starts with empty messages", () =>
   Effect
     .gen(function*() {
       const logger = yield* TestLogger.TestLogger
       const messages = yield* Ref.get(logger.messages)
 
-      t.expect(messages).toHaveLength(0)
+      test
+        .expect(messages)
+        .toHaveLength(0)
     })
     .pipe(Effect.provide(TestLogger.layer()), Effect.runPromise))

package/src/testing/TestLogger.ts

@@ -1,9 +1,11 @@
+import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
 import * as Logger from "effect/Logger"
+import * as MutableRef from "effect/MutableRef"
 import * as Ref from "effect/Ref"
 
 export type TestLoggerContext = {
@@ -20,13 +22,19 @@ export function layer(): Layer.Layer<TestLogger> {
     TestLogger,
     Effect.gen(function*() {
       const messages = yield* Ref.make<Array<string>>([])
+      const mutableRef = (messages as any).ref as MutableRef.MutableRef<
+        Array<string>
+      >
 
-      const customLogger = Logger.make(({ message, logLevel }) => {
-        Effect.runSync(
-          Ref.update(
-            messages,
-            (msgs) => [...msgs, `[${logLevel._tag}] ${String(message)}`],
-          ),
+      const customLogger = Logger.make(({ message, logLevel, cause }) => {
+        const causeStr = !Cause.isEmpty(cause)
+          ? ` ${Cause.pretty(cause)}`
+          : ""
+        MutableRef.update(
+          mutableRef,
+          (
+            msgs,
+          ) => [...msgs, `[${logLevel._tag}] ${String(message)}${causeStr}`],
         )
       })
 
@@ -39,9 +47,7 @@ export function layer(): Layer.Layer<TestLogger> {
           ),
       )
 
-      return {
-        messages,
-      }
+      return { messages }
     }),
   )
 }

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

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

package/src/x/datastar/Datastar.ts

@@ -1,4 +1,4 @@
-import * as HyperNode from "../../HyperNode.ts"
+import * as HyperNode from "../../hyper/HyperNode.ts"
 
 export const HyperHooks = {
   onNode,