effect-start 0.16.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -14,6 +14,7 @@
     "./middlewares": "./src/middlewares/index.ts",
     "./experimental": "./src/experimental/index.ts",
     "./client/assets.d.ts": "./src/assets.d.ts",
+    "./hyper": "./src/hyper/index.ts",
     "./jsx-runtime": "./src/hyper/jsx-runtime.ts",
     "./jsx-dev-runtime": "./src/hyper/jsx-runtime.ts",
     "./package.json": "./package.json"

package/src/Development.test.ts

@@ -0,0 +1,119 @@
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as test from "bun:test"
+import { MemoryFileSystem } from "effect-memfs"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Layer from "effect/Layer"
+import * as Stream from "effect/Stream"
+import * as Development from "./Development.ts"
+
+test.beforeEach(() => {
+  Development._resetForTesting()
+})
+
+test.describe("watch", () => {
+  test.it("creates pubsub and publishes file events", () =>
+    Effect
+      .gen(function*() {
+        const fs = yield* FileSystem.FileSystem
+        const watchDir = "/dev-watch"
+
+        const dev = yield* Development.watch({ path: watchDir })
+
+        const subFiber = yield* Effect.fork(
+          Stream.runCollect(
+            Stream.take(Stream.fromPubSub(dev.events), 1),
+          ),
+        )
+
+        yield* Effect.sleep(1)
+        yield* fs.writeFileString(`${watchDir}/test.ts`, "const x = 1")
+
+        const events = yield* Fiber.join(subFiber)
+
+        test
+          .expect(Chunk.size(events))
+          .toBe(1)
+        const first = Chunk.unsafeGet(events, 0)
+        test
+          .expect("path" in first && first.path)
+          .toContain("test.ts")
+      })
+      .pipe(
+        Effect.scoped,
+        Effect.provide(
+          MemoryFileSystem.layerWith({ "/dev-watch/.gitkeep": "" }),
+        ),
+        Effect.runPromise,
+      ))
+})
+
+test.describe("layerWatch", () => {
+  test.it("provides Development service", () =>
+    Effect
+      .gen(function*() {
+        const dev = yield* Development.Development
+
+        test
+          .expect(dev.events)
+          .toBeDefined()
+      })
+      .pipe(
+        Effect.scoped,
+        Effect.provide(Development.layerWatch({ path: "/layer-test" })),
+        Effect.provide(
+          MemoryFileSystem.layerWith({ "/layer-test/.gitkeep": "" }),
+        ),
+        Effect.runPromise,
+      ))
+})
+
+test.describe("stream", () => {
+  test.it("returns stream from pubsub when Development is available", () =>
+    Effect
+      .gen(function*() {
+        const fs = yield* FileSystem.FileSystem
+        const watchDir = "/events-test"
+
+        const collectFiber = yield* Effect.fork(
+          Stream.runCollect(Stream.take(Development.stream(), 1)),
+        )
+
+        yield* Effect.sleep(1)
+        yield* fs.writeFileString(`${watchDir}/file.ts`, "content")
+
+        const collected = yield* Fiber.join(collectFiber)
+
+        test
+          .expect(Chunk.size(collected))
+          .toBe(1)
+        const first = Chunk.unsafeGet(collected, 0)
+        test
+          .expect("path" in first && first.path)
+          .toContain("file.ts")
+      })
+      .pipe(
+        Effect.scoped,
+        Effect.provide(Development.layerWatch({ path: "/events-test" })),
+        Effect.provide(
+          MemoryFileSystem.layerWith({ "/events-test/.gitkeep": "" }),
+        ),
+        Effect.runPromise,
+      ))
+
+  test.it("returns empty stream when Development is not available", () =>
+    Effect
+      .gen(function*() {
+        const collected = yield* Stream.runCollect(Development.stream())
+
+        test
+          .expect(Chunk.size(collected))
+          .toBe(0)
+      })
+      .pipe(
+        Effect.scoped,
+        Effect.provide(Layer.empty),
+        Effect.runPromise,
+      ))
+})

package/src/Development.ts

@@ -0,0 +1,137 @@
+import {
+  Context,
+  Effect,
+  Function,
+  Layer,
+  Option,
+  pipe,
+  PubSub,
+  Stream,
+} from "effect"
+import { globalValue } from "effect/GlobalValue"
+import {
+  Error,
+  FileSystem,
+} from "./node/FileSystem.ts"
+
+export type DevelopmentEvent =
+  | FileSystem.WatchEvent
+  | {
+    readonly _tag: "Reload"
+  }
+
+const devState = globalValue(
+  Symbol.for("effect-start/Development"),
+  () => ({
+    count: 0,
+    pubsub: null as PubSub.PubSub<DevelopmentEvent> | null,
+  }),
+)
+
+/** @internal */
+export const _resetForTesting = () => {
+  devState.count = 0
+  devState.pubsub = null
+}
+
+export type DevelopmentService = {
+  events: PubSub.PubSub<DevelopmentEvent>
+}
+
+export class Development extends Context.Tag("effect-start/Development")<
+  Development,
+  DevelopmentService
+>() {}
+
+const SOURCE_FILENAME = /\.(tsx?|jsx?|html?|css|json)$/
+
+export const filterSourceFiles = (event: FileSystem.WatchEvent): boolean => {
+  return SOURCE_FILENAME.test(event.path)
+}
+
+export const filterDirectory = (event: FileSystem.WatchEvent): boolean => {
+  return event.path.endsWith("/")
+}
+
+export const watchSource = (
+  opts?: {
+    path?: string
+    recursive?: boolean
+    filter?: (event: FileSystem.WatchEvent) => boolean
+  },
+): Stream.Stream<
+  FileSystem.WatchEvent,
+  Error.PlatformError,
+  FileSystem.FileSystem
+> => {
+  const baseDir = opts?.path ?? process.cwd()
+  const customFilter = opts?.filter
+
+  return Function.pipe(
+    Stream.unwrap(
+      Effect.map(
+        FileSystem.FileSystem,
+        fs => fs.watch(baseDir, { recursive: opts?.recursive ?? true }),
+      ),
+    ),
+    customFilter ? Stream.filter(customFilter) : Function.identity,
+    Stream.rechunk(1),
+    Stream.throttle({
+      units: 1,
+      cost: () => 1,
+      duration: "400 millis",
+      strategy: "enforce",
+    }),
+  )
+}
+
+export const watch = (
+  opts?: {
+    path?: string
+    recursive?: boolean
+    filter?: (event: FileSystem.WatchEvent) => boolean
+  },
+) =>
+  Effect.gen(function*() {
+    devState.count++
+
+    if (devState.count === 1) {
+      const pubsub = yield* PubSub.unbounded<DevelopmentEvent>()
+      devState.pubsub = pubsub
+
+      yield* pipe(
+        watchSource({
+          path: opts?.path,
+          recursive: opts?.recursive,
+          filter: opts?.filter ?? filterSourceFiles,
+        }),
+        Stream.runForEach((event) => PubSub.publish(pubsub, event)),
+        Effect.fork,
+      )
+    } else {
+      yield* PubSub.publish(devState.pubsub!, { _tag: "Reload" })
+    }
+
+    return { events: devState.pubsub! } satisfies DevelopmentService
+  })
+
+export const layerWatch = (
+  opts?: {
+    path?: string
+    recursive?: boolean
+    filter?: (event: FileSystem.WatchEvent) => boolean
+  },
+) => Layer.scoped(Development, watch(opts))
+
+export const stream = (): Stream.Stream<DevelopmentEvent> =>
+  Stream.unwrap(
+    pipe(
+      Effect.serviceOption(Development),
+      Effect.map(
+        Option.match({
+          onNone: () => Stream.empty,
+          onSome: (dev) => Stream.fromPubSub(dev.events),
+        }),
+      ),
+    ),
+  )

package/src/Entity.test.ts

@@ -366,7 +366,7 @@ test.describe("bytes", () => {
 
     test
       .expect(text)
-      .toBe('{"key":"value"}')
+      .toBe("{\"key\":\"value\"}")
   })
 })
 

package/src/Entity.ts

@@ -39,11 +39,9 @@ export interface Entity<
    */
   readonly url: string | undefined
   readonly status: number | undefined
-  readonly text: T extends string
-    ? Effect.Effect<T, ParseResult.ParseError | E>
+  readonly text: T extends string ? Effect.Effect<T, ParseResult.ParseError | E>
     : Effect.Effect<string, ParseResult.ParseError | E>
-  readonly json: [T] extends [Effect.Effect<infer A, any, any>]
-    ? Effect.Effect<
+  readonly json: [T] extends [Effect.Effect<infer A, any, any>] ? Effect.Effect<
       A extends string | Uint8Array | ArrayBuffer ? unknown : A,
       ParseResult.ParseError | E
     >
@@ -51,8 +49,7 @@ export interface Entity<
       ? Effect.Effect<unknown, ParseResult.ParseError | E>
     : [T] extends [string | Uint8Array | ArrayBuffer]
       ? Effect.Effect<unknown, ParseResult.ParseError | E>
-    : [T] extends [Values.Json]
-      ? Effect.Effect<T, ParseResult.ParseError | E>
+    : [T] extends [Values.Json] ? Effect.Effect<T, ParseResult.ParseError | E>
     : Effect.Effect<unknown, ParseResult.ParseError | E>
   readonly bytes: Effect.Effect<Uint8Array, ParseResult.ParseError | E>
   readonly stream: T extends Stream.Stream<infer A, infer E1, any>

package/src/FileRouter.ts

@@ -10,9 +10,9 @@ import * as Record from "effect/Record"
 import * as Stream from "effect/Stream"
 import * as NPath from "node:path"
 import * as NUrl from "node:url"
+import * as Development from "./Development.ts"
 import * as FileRouterCodegen from "./FileRouterCodegen.ts"
 import * as FileRouterPattern from "./FileRouterPattern.ts"
-import * as FileSystemExtra from "./FileSystemExtra.ts"
 
 export type RouteModule = {
   default: RouteSet.RouteSet.Default
@@ -161,7 +161,7 @@ export function layer(options: {
         yield* FileRouterCodegen.update(routesPath, manifestFilename)
 
         const stream = Function.pipe(
-          FileSystemExtra.watchSource({
+          Development.watchSource({
             path: routesPath,
             filter: (e) => !e.path.includes("node_modules"),
           }),

package/src/Route.ts

@@ -323,6 +323,10 @@ export {
   render,
 } from "./RouteBody.ts"
 
+export {
+  sse,
+} from "./RouteSse.ts"
+
 export class Routes extends Context.Tag("effect-start/Routes")<
   Routes,
   RouteTree.RouteTree

package/src/RouteBody.test.ts

@@ -1,5 +1,6 @@
 import * as test from "bun:test"
 import * as Effect from "effect/Effect"
+import * as ParseResult from "effect/ParseResult"
 import * as Stream from "effect/Stream"
 import * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
@@ -107,51 +108,36 @@ test.describe(`${RouteBody.handle.name}()`, () => {
   })
 
   test.it("handles plain value", async () => {
-    const handler = RouteBody.handle("hello")
-
-    test
-      .expectTypeOf(handler)
-      .returns
-      .toEqualTypeOf<
-        Effect.Effect<Entity.Entity<string>, never, never>
-      >()
-
+    const handler = RouteBody.handle<{}, string, never, never>("hello")
     const result = await Effect.runPromise(handler(ctx, next))
     test.expect(result.body).toBe("hello")
     test.expect(result.status).toBe(200)
   })
 
   test.it("handles Effect directly", async () => {
-    const handler = RouteBody.handle(Effect.succeed("from effect"))
-
-    test
-      .expectTypeOf(handler)
-      .returns
-      .toEqualTypeOf<
-        Effect.Effect<Entity.Entity<string>, never, never>
-      >()
-
+    const handler = RouteBody.handle<{}, string, never, never>(
+      Effect.succeed("from effect"),
+    )
     const result = await Effect.runPromise(handler(ctx, next))
-
-    test
-      .expect(result.body)
-      .toBe("from effect")
+    test.expect(result.body).toBe("from effect")
   })
 
   test.it("handles Effect with error", async () => {
-    const handler = RouteBody.handle(Effect.fail(new Error("oops")))
+    const handler = RouteBody.handle<{}, never, Error, never>(
+      Effect.fail(new Error("oops")),
+    )
 
     test
       .expectTypeOf(handler)
       .returns
-      .toEqualTypeOf<
+      .toExtend<
         Effect.Effect<Entity.Entity<never>, Error, never>
       >()
   })
 
   test.it("handles function", async () => {
-    const handler = RouteBody.handle(
-      (ctx: { id: number }) => Effect.succeed(ctx.id),
+    const handler = RouteBody.handle<{ id: number }, number, never, never>(
+      (ctx) => Effect.succeed(ctx.id),
     )
 
     test
@@ -173,20 +159,18 @@ test.describe(`${RouteBody.handle.name}()`, () => {
       >()
 
     const numNext = () => Entity.effect(Effect.succeed(Entity.make(23)))
-    const result = await Effect.runPromise(
-      handler({ id: 42 }, numNext),
-    )
+    const result = await Effect.runPromise(handler({ id: 42 }, numNext))
 
-    test
-      .expect(result.body)
-      .toBe(42)
+    test.expect(result.body).toBe(42)
   })
 
   test.it("handles generator", async () => {
-    const handler = RouteBody.handle(function*(ctx: { id: number }) {
-      const n = yield* Effect.succeed(ctx.id)
-      return n * 2
-    })
+    const handler = RouteBody.handle<{ id: number }, number, never, never>(
+      function*(ctx) {
+        const n = yield* Effect.succeed(ctx.id)
+        return n * 2
+      },
+    )
 
     test
       .expectTypeOf(handler)
@@ -208,24 +192,20 @@ test.describe(`${RouteBody.handle.name}()`, () => {
       >()
 
     const numNext = () => Entity.effect(Effect.succeed(Entity.make(23)))
-    const result = await Effect.runPromise(
-      handler({ id: 21 }, numNext),
-    )
+    const result = await Effect.runPromise(handler({ id: 21 }, numNext))
 
-    test
-      .expect(result.body)
-      .toBe(42)
+    test.expect(result.body).toBe(42)
   })
 
   test.it("generator can call next", async () => {
-    const handler = RouteBody.handle(
-      function*(_ctx: {}, next: () => Entity.Entity<string>) {
+    const handler = RouteBody.handle<{}, string, ParseResult.ParseError, never>(
+      function*(_ctx, next) {
         const fromNext = yield* next().text
         return `got: ${fromNext}`
       },
     )
 
-    const result = await Effect.runPromise(handler(ctx, next))
+    const result = await Effect.runPromise(Effect.orDie(handler(ctx, next)))
 
     test
       .expect(result.body)

package/src/RouteBody.ts

@@ -115,14 +115,17 @@ export function build<
         E,
         R
       > = (ctx, next) =>
-        Effect.map(baseHandler(ctx as any, next as any), (entity) =>
-          entity.headers["content-type"]
-            ? entity
-            : Entity.make(entity.body, {
-              status: entity.status,
-              url: entity.url,
-              headers: { ...entity.headers, "content-type": contentType },
-            }))
+        Effect.map(
+          baseHandler(ctx as any, next as any),
+          (entity) =>
+            entity.headers["content-type"]
+              ? entity
+              : Entity.make(entity.body, {
+                status: entity.status,
+                url: entity.url,
+                headers: { ...entity.headers, "content-type": contentType },
+              }),
+        )
 
       const route = Route.make<{ format: F }, {}, A, E, R>(
         wrappedHandler as any,

package/src/RouteHttp.test.ts

@@ -2571,7 +2571,10 @@ test.describe("Route.render (format=*)", () => {
     )
 
     const responses = await Promise.all([
-      Http.fetch(handler, { path: "/", headers: { Accept: "text/event-stream" } }),
+      Http.fetch(handler, {
+        path: "/",
+        headers: { Accept: "text/event-stream" },
+      }),
       Http.fetch(handler, { path: "/", headers: { Accept: "image/png" } }),
       Http.fetch(handler, { path: "/", headers: { Accept: "*/*" } }),
       Http.fetch(handler, { path: "/" }),

package/src/RouteHttp.ts

@@ -211,7 +211,9 @@ export const toWebHandlerRuntime = <R>(
 
       if (methodRoutes.length === 0 && wildcards.length === 0) {
         return Promise.resolve(
-          Response.json({ status: 405, message: "method not allowed" }, { status: 405 }),
+          Response.json({ status: 405, message: "method not allowed" }, {
+            status: 405,
+          }),
         )
       }
 
@@ -232,7 +234,9 @@ export const toWebHandlerRuntime = <R>(
         && !hasWildcardFormatRoutes
       ) {
         return Promise.resolve(
-          Response.json({ status: 406, message: "not acceptable" }, { status: 406 }),
+          Response.json({ status: 406, message: "not acceptable" }, {
+            status: 406,
+          }),
         )
       }
 
@@ -311,7 +315,9 @@ export const toWebHandlerRuntime = <R>(
               : Entity.make(result, { status: 200 })
 
             if (entity.status === 404 && entity.body === undefined) {
-              return Response.json({ status: 406, message: "not acceptable" }, { status: 406 })
+              return Response.json({ status: 406, message: "not acceptable" }, {
+                status: 406,
+              })
             }
 
             return yield* toResponse(entity, selectedFormat, runtime)
@@ -374,7 +380,9 @@ export const toWebHandlerRuntime = <R>(
               Effect.gen(function*() {
                 yield* Effect.logError(cause)
                 const status = getStatusFromCause(cause)
-                return Response.json({ status, message: Cause.pretty(cause) }, { status })
+                return Response.json({ status, message: Cause.pretty(cause) }, {
+                  status,
+                })
               })
             ),
           ),
@@ -392,10 +400,18 @@ export const toWebHandlerRuntime = <R>(
           if (exit._tag === "Success") {
             resolve(exit.value)
           } else if (isClientAbort(exit.cause)) {
-            resolve(Response.json({ status: 499, message: "client closed request" }, { status: 499 }))
+            resolve(
+              Response.json({ status: 499, message: "client closed request" }, {
+                status: 499,
+              }),
+            )
           } else {
             const status = getStatusFromCause(exit.cause)
-            resolve(Response.json({ status, message: Cause.pretty(exit.cause) }, { status }))
+            resolve(
+              Response.json({ status, message: Cause.pretty(exit.cause) }, {
+                status,
+              }),
+            )
           }
         })
       })