effect-start 0.16.0 → 0.17.0

package/src/RouteSse.test.ts

@@ -0,0 +1,249 @@
+import * as test from "bun:test"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Runtime from "effect/Runtime"
+import * as Stream from "effect/Stream"
+import * as Http from "./Http.ts"
+import * as Route from "./Route.ts"
+import * as RouteHttp from "./RouteHttp.ts"
+import * as RouteMount from "./RouteMount.ts"
+
+test.describe("Route.sse()", () => {
+  test.it("infers format as text", () => {
+    RouteMount.get(
+      Route.sse(function*(ctx) {
+        test
+          .expectTypeOf(ctx)
+          .toExtend<{
+            method: "GET"
+            format: "text"
+          }>()
+
+        return Stream.make({ data: "hello" })
+      }),
+    )
+  })
+
+  test.it("accepts object events with data only", () => {
+    RouteMount.get(
+      Route.sse(() =>
+        Stream.make(
+          { data: "hello" },
+          { data: "world" },
+        )
+      ),
+    )
+  })
+
+  test.it("accepts object events with data and event", () => {
+    RouteMount.get(
+      Route.sse(() =>
+        Stream.make(
+          { data: "hello", event: "message" },
+          { data: "world", event: "update" },
+        )
+      ),
+    )
+  })
+
+  test.it("accepts events with retry", () => {
+    RouteMount.get(
+      Route.sse(() =>
+        Stream.make(
+          { data: "hello", retry: 3000 },
+        )
+      ),
+    )
+  })
+
+  test.it("accepts Effect returning Stream", () => {
+    RouteMount.get(
+      Route.sse(
+        Effect.succeed(Stream.make({ data: "hello" })),
+      ),
+    )
+  })
+
+  test.it("accepts generator returning Stream", () => {
+    RouteMount.get(
+      Route.sse(function*() {
+        const prefix = yield* Effect.succeed("msg: ")
+        return Stream.make({ data: `${prefix}hello` })
+      }),
+    )
+  })
+
+  test.it("formats data events correctly", async () => {
+    const handler = RouteHttp.toWebHandler(
+      Route.get(
+        Route.sse(() => Stream.make({ data: "hello" }, { data: "world" })),
+      ),
+    )
+    const response = await Http.fetch(handler, { path: "/events" })
+
+    test.expect(response.headers.get("content-type")).toBe("text/event-stream")
+    test.expect(response.headers.get("cache-control")).toBe("no-cache")
+    test.expect(response.headers.get("connection")).toBe("keep-alive")
+
+    const text = await response.text()
+    test.expect(text).toBe("data: hello\n\ndata: world\n\n")
+  })
+
+  test.it("formats events with event field", async () => {
+    const handler = RouteHttp.toWebHandler(
+      Route.get(
+        Route.sse(() => Stream.make({ data: "payload", event: "custom" })),
+      ),
+    )
+    const response = await Http.fetch(handler, { path: "/events" })
+
+    const text = await response.text()
+    test.expect(text).toBe("event: custom\ndata: payload\n\n")
+  })
+
+  test.it("formats events with retry", async () => {
+    const handler = RouteHttp.toWebHandler(
+      Route.get(
+        Route.sse(() => Stream.make({ data: "hello", retry: 5000 })),
+      ),
+    )
+    const response = await Http.fetch(handler, { path: "/events" })
+
+    const text = await response.text()
+    test.expect(text).toBe("data: hello\nretry: 5000\n\n")
+  })
+
+  test.it("formats multi-line data with multiple data fields", async () => {
+    const handler = RouteHttp.toWebHandler(
+      Route.get(
+        Route.sse(() =>
+          Stream.make({
+            event: "patch",
+            data: "line1\nline2\nline3",
+          })
+        ),
+      ),
+    )
+    const response = await Http.fetch(handler, { path: "/events" })
+
+    const text = await response.text()
+    test.expect(text).toBe(
+      "event: patch\ndata: line1\ndata: line2\ndata: line3\n\n",
+    )
+  })
+
+  test.it("accepts Stream directly", async () => {
+    const handler = RouteHttp.toWebHandler(
+      Route.get(
+        Route.sse(
+          Stream.make({ data: "direct" }),
+        ),
+      ),
+    )
+    const response = await Http.fetch(handler, { path: "/events" })
+
+    const text = await response.text()
+    test.expect(text).toBe("data: direct\n\n")
+  })
+
+  test.it("infers error type from Stream", () => {
+    class MyError {
+      readonly _tag = "MyError"
+    }
+
+    const stream: Stream.Stream<{ data: string }, MyError> = Stream.fail(
+      new MyError(),
+    )
+
+    const route = Route.get(
+      Route.sse(stream),
+    )
+
+    const routes = [...route]
+    type RouteError = (typeof routes)[0] extends
+      Route.Route.Route<any, any, any, infer E, any> ? E
+      : never
+
+    test.expectTypeOf<RouteError>().toEqualTypeOf<MyError>()
+  })
+
+  test.it("infers context type from Stream", () => {
+    class Config extends Context.Tag("Config")<Config, { url: string }>() {}
+
+    const stream = Stream.fromEffect(
+      Effect.map(Config, (cfg) => ({ data: cfg.url })),
+    )
+
+    const route = Route.get(
+      Route.sse(stream),
+    )
+
+    const routes = [...route]
+    type RouteContext = (typeof routes)[0] extends
+      Route.Route.Route<any, any, any, any, infer R> ? R
+      : never
+
+    test.expectTypeOf<RouteContext>().toEqualTypeOf<Config>()
+  })
+
+  test.it("works with context at runtime", async () => {
+    class Config extends Context.Tag("Config")<Config, { message: string }>() {}
+
+    const stream = Stream.fromEffect(
+      Effect.map(Config, (cfg) => ({ data: cfg.message })),
+    )
+
+    const route = Route.get(Route.sse(stream))
+    const layer = Layer.succeed(Config, { message: "from context" })
+    const runtime = Effect.runSync(Layer.toRuntime(layer).pipe(Effect.scoped))
+    const handler = RouteHttp.toWebHandlerRuntime(runtime)(route)
+
+    const response = await Http.fetch(handler, { path: "/events" })
+    const text = await response.text()
+
+    test.expect(text).toBe("data: from context\n\n")
+  })
+
+  test.it("formats tagged struct as event with JSON data", async () => {
+    const handler = RouteHttp.toWebHandler(
+      Route.get(
+        Route.sse(() =>
+          Stream.make(
+            { _tag: "UserCreated", id: 123, name: "Alice" },
+            { _tag: "UserUpdated", id: 123, active: true },
+          )
+        ),
+      ),
+    )
+    const response = await Http.fetch(handler, { path: "/events" })
+
+    const text = await response.text()
+    test.expect(text).toBe(
+      `event: UserCreated\ndata: {"_tag":"UserCreated","id":123,"name":"Alice"}\n\n`
+        + `event: UserUpdated\ndata: {"_tag":"UserUpdated","id":123,"active":true}\n\n`,
+    )
+  })
+
+  test.it("handles mixed tagged and regular events", async () => {
+    const handler = RouteHttp.toWebHandler(
+      Route.get(
+        Route.sse(() =>
+          Stream.make(
+            { data: "plain message" },
+            { _tag: "Notification", text: "hello" },
+            { data: "another", event: "custom" },
+          )
+        ),
+      ),
+    )
+    const response = await Http.fetch(handler, { path: "/events" })
+
+    const text = await response.text()
+    test.expect(text).toBe(
+      `data: plain message\n\n`
+        + `event: Notification\ndata: {"_tag":"Notification","text":"hello"}\n\n`
+        + `event: custom\ndata: another\n\n`,
+    )
+  })
+})

package/src/RouteSse.ts

@@ -0,0 +1,195 @@
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Schedule from "effect/Schedule"
+import * as Stream from "effect/Stream"
+import type * as Utils from "effect/Utils"
+import * as Entity from "./Entity.ts"
+import * as Route from "./Route.ts"
+import * as StreamExtra from "./StreamExtra.ts"
+import type * as Values from "./Values.ts"
+
+const HEARTBEAT_INTERVAL = Duration.seconds(5)
+const HEARTBEAT = ": <3\n\n"
+
+export interface SseEvent {
+  data?: string | undefined
+  event?: string
+  retry?: number
+}
+
+export type SseTaggedEvent = {
+  readonly _tag: string
+}
+
+export type SseEventInput =
+  | SseEvent
+  | SseTaggedEvent
+
+function isTaggedEvent(event: SseEventInput): event is SseTaggedEvent {
+  return Object.hasOwn(event, "_tag")
+    && typeof event["_tag"] === "string"
+}
+
+function formatSseEvent(event: SseEventInput): string {
+  if (isTaggedEvent(event)) {
+    const json = JSON.stringify(event)
+    return `event: ${event._tag}\ndata: ${json}\n\n`
+  }
+
+  const e = event as SseEvent
+  let result = ""
+  if (e.event) {
+    result += `event: ${e.event}\n`
+  }
+  if (typeof e.data === "string") {
+    for (const line of e.data.split("\n")) {
+      result += `data: ${line}\n`
+    }
+  }
+  if (e.retry !== undefined) {
+    result += `retry: ${e.retry}\n`
+  }
+  if (result === "") {
+    return ""
+  }
+  return result + "\n"
+}
+
+export type SseHandlerInput<B, E, R> =
+  | Stream.Stream<SseEventInput, E, R>
+  | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+  | ((
+    context: Values.Simplify<B>,
+    next: (
+      context?: Partial<B> & Record<string, unknown>,
+    ) => Entity.Entity<string>,
+  ) =>
+    | Stream.Stream<SseEventInput, E, R>
+    | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+    | Generator<
+      Utils.YieldWrap<Effect.Effect<unknown, E, R>>,
+      Stream.Stream<SseEventInput, E, R>,
+      unknown
+    >)
+
+export function sse<
+  D extends Route.RouteDescriptor.Any,
+  B extends {},
+  I extends Route.Route.Tuple,
+  E = never,
+  R = never,
+>(
+  handler: SseHandlerInput<
+    NoInfer<D & B & Route.ExtractBindings<I> & { format: "text" }>,
+    E,
+    R
+  >,
+) {
+  return function(
+    self: Route.RouteSet.RouteSet<D, B, I>,
+  ) {
+    const sseHandler: Route.Route.Handler<
+      D & B & Route.ExtractBindings<I> & { format: "text" },
+      Stream.Stream<string, E, R>,
+      E,
+      R
+    > = (ctx, _next) => {
+      const getStream = (): Effect.Effect<
+        Stream.Stream<SseEventInput, E, R>,
+        E,
+        R
+      > => {
+        if (typeof handler === "function") {
+          const result = (handler as Function)(ctx, _next)
+          if (StreamExtra.isStream(result)) {
+            return Effect.succeed(result as Stream.Stream<SseEventInput, E, R>)
+          }
+          if (Effect.isEffect(result)) {
+            return result as Effect.Effect<
+              Stream.Stream<SseEventInput, E, R>,
+              E,
+              R
+            >
+          }
+          return Effect.gen(function*() {
+            return yield* result
+          }) as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+        }
+        if (StreamExtra.isStream(handler)) {
+          return Effect.succeed(handler as Stream.Stream<SseEventInput, E, R>)
+        }
+        if (Effect.isEffect(handler)) {
+          return handler as Effect.Effect<
+            Stream.Stream<SseEventInput, E, R>,
+            E,
+            R
+          >
+        }
+        return Effect.succeed(Stream.empty)
+      }
+
+      return Effect.map(getStream(), (eventStream) => {
+        const formattedStream = Stream.map(eventStream, formatSseEvent)
+        const heartbeat = Stream
+          .repeat(
+            Stream.succeed(HEARTBEAT),
+            Schedule.spaced(HEARTBEAT_INTERVAL),
+          )
+          .pipe(Stream.drop(1))
+        const merged = Stream.merge(formattedStream, heartbeat, {
+          haltStrategy: "left",
+        })
+        return Entity.make(merged, {
+          headers: {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache",
+            "connection": "keep-alive",
+          },
+        })
+      })
+    }
+
+    const route = Route.make<
+      { format: "text" },
+      {},
+      Stream.Stream<string, E, R>,
+      E,
+      R
+    >(
+      sseHandler as any,
+      { format: "text" },
+    )
+
+    const items: [
+      ...I,
+      Route.Route.Route<
+        { format: "text" },
+        {},
+        Stream.Stream<string, E, R>,
+        E,
+        R
+      >,
+    ] = [
+      ...Route.items(self),
+      route,
+    ]
+
+    return Route.set<
+      D,
+      B,
+      [
+        ...I,
+        Route.Route.Route<
+          { format: "text" },
+          {},
+          Stream.Stream<string, E, R>,
+          E,
+          R
+        >,
+      ]
+    >(
+      items,
+      Route.descriptor(self),
+    )
+  }
+}

package/src/Values.ts

@@ -4,16 +4,18 @@ type JsonPrimitives =
   | boolean
   | null
 
+export type JsonObject = {
+  [key: string]:
+    | Json
+    // undefined won't be included in JSON objects but this will allow
+    // to use Json type in functions that return object of multiple shapes
+    | undefined
+}
+
 export type Json =
   | JsonPrimitives
   | Json[]
-  | {
-    [key: string]:
-      | Json
-      // undefined won't be included in JSON objects but this will allow
-      // to use Json type in functions that return object of multiple shapes
-      | undefined
-  }
+  | JsonObject
 
 export function isPlainObject(
   value: unknown,

package/src/bun/BunBundle.ts

@@ -9,10 +9,7 @@ import {
   Iterable,
   Layer,
   pipe,
-  PubSub,
   Record,
-  Stream,
-  SynchronizedRef,
 } from "effect"
 import * as NPath from "node:path"
 import type {
@@ -20,7 +17,6 @@ import type {
   BundleManifest,
 } from "../bundler/Bundle.ts"
 import * as Bundle from "../bundler/Bundle.ts"
-import * as FileSystemExtra from "../FileSystemExtra.ts"
 import { BunImportTrackerPlugin } from "./index.ts"
 
 export type BuildOptions = Omit<
@@ -125,75 +121,6 @@ export function layer<T>(
   return Layer.effect(tag, build(config))
 }
 
-export function layerDev<T>(
-  tag: Context.Tag<T, BundleContext>,
-  config: BuildOptions,
-) {
-  return Layer.scoped(
-    tag,
-    Effect.gen(function*() {
-      const loadRefKey = "_loadRef"
-      const sharedBundle = yield* build(config)
-
-      const loadRef = yield* SynchronizedRef.make(null)
-      sharedBundle[loadRefKey] = loadRef
-      sharedBundle.events = yield* PubSub.unbounded<Bundle.BundleEvent>()
-
-      yield* Effect.fork(
-        pipe(
-          FileSystemExtra.watchSource({
-            filter: FileSystemExtra.filterSourceFiles,
-          }),
-          Stream.map(v =>
-            ({
-              _tag: "Change",
-              path: v.path,
-            }) as Bundle.BundleEvent
-          ),
-          Stream.onError(err =>
-            Effect.logError("Error while watching files", err)
-          ),
-          Stream.runForEach((v) =>
-            pipe(
-              Effect.gen(function*() {
-                yield* Effect.logDebug("Updating bundle: " + tag.key)
-
-                const newBundle = yield* build(config)
-
-                Object.assign(sharedBundle, newBundle)
-
-                // Clean old loaded bundle
-                yield* SynchronizedRef.update(loadRef, () => null)
-
-                // publish event after the built
-                if (sharedBundle.events) {
-                  yield* PubSub.publish(sharedBundle.events, v)
-                }
-              }),
-              Effect.catchAll(err =>
-                Effect.gen(function*() {
-                  yield* Effect.logError(
-                    "Error while updating bundle",
-                    err,
-                  )
-                  if (sharedBundle.events) {
-                    yield* PubSub.publish(sharedBundle.events, {
-                      _tag: "BuildError",
-                      error: String(err),
-                    })
-                  }
-                })
-              ),
-            )
-          ),
-        ),
-      )
-
-      return sharedBundle
-    }),
-  )
-}
-
 /**
  * Finds common path prefix across provided paths.
  */

package/src/bun/BunRoute.ts

@@ -162,8 +162,6 @@ export function htmlBundle(
   }
 }
 
-
-
 type BunServerFetchHandler = (
   request: Request,
   server: Bun.Server<unknown>,

package/src/hyper/HyperHtml.test.ts

@@ -88,3 +88,122 @@ test.it("mixed boolean and string attributes", () => {
     .expect(html)
     .toBe("<input type=\"checkbox\" checked name=\"test\" value=\"on\">")
 })
+
+test.it("data-* attributes with object values are JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    "data-signals": {
+      draft: "",
+      pendingDraft: "",
+      username: "User123",
+    },
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toBe(
+      "<div data-signals=\"{&quot;draft&quot;:&quot;&quot;,&quot;pendingDraft&quot;:&quot;&quot;,&quot;username&quot;:&quot;User123&quot;}\"></div>",
+    )
+})
+
+test.it("data-* attributes with array values are JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    "data-items": [1, 2, 3],
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toBe("<div data-items=\"[1,2,3]\"></div>")
+})
+
+test.it("data-* attributes with nested object values", () => {
+  const node = HyperNode.make("div", {
+    "data-config": {
+      user: { name: "John", active: true },
+      settings: { theme: "dark" },
+    },
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toBe(
+      "<div data-config=\"{&quot;user&quot;:{&quot;name&quot;:&quot;John&quot;,&quot;active&quot;:true},&quot;settings&quot;:{&quot;theme&quot;:&quot;dark&quot;}}\"></div>",
+    )
+})
+
+test.it("data-* string values are not JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    "data-value": "hello world",
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toBe("<div data-value=\"hello world\"></div>")
+})
+
+test.it("non-data attributes with object values are not JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    style: "color: red",
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toBe("<div style=\"color: red\"></div>")
+})
+
+test.it("script with function child renders as IIFE", () => {
+  const handler = (window: Window) => {
+    console.log("Hello from", window.document.title)
+  }
+
+  const node = HyperNode.make("script", {
+    children: handler,
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toBe(`<script>(${handler.toString()})(window)</script>`)
+})
+
+test.it("script with arrow function child renders as IIFE", () => {
+  const node = HyperNode.make("script", {
+    children: (window: Window) => {
+      window.alert("test")
+    },
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toContain("<script>(")
+  test
+    .expect(html)
+    .toContain(")(window)</script>")
+  test
+    .expect(html)
+    .toContain("window.alert")
+})
+
+test.it("script with string child renders normally", () => {
+  const node = HyperNode.make("script", {
+    children: "console.log('hello')",
+  })
+
+  const html = HyperHtml.renderToString(node)
+
+  test
+    .expect(html)
+    .toBe("<script>console.log(&apos;hello&apos;)</script>")
+})