effect-start 0.15.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.15.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/ContentNegotiation.test.ts

@@ -148,6 +148,109 @@ test.describe("ContentNegotiation.media", () => {
       .expect(result)
       .toEqual(["text/html", "application/json"])
   })
+
+  test.describe("wildcard in available types", () => {
+    test.it("text/* matches text/event-stream", () => {
+      const result = ContentNegotiation.media(
+        "text/event-stream",
+        ["text/*", "application/json"],
+      )
+      test
+        .expect(result)
+        .toEqual(["text/*"])
+    })
+
+    test.it("text/* matches text/markdown", () => {
+      const result = ContentNegotiation.media(
+        "text/markdown",
+        ["text/*"],
+      )
+      test
+        .expect(result)
+        .toEqual(["text/*"])
+    })
+
+    test.it("text/* matches text/plain", () => {
+      const result = ContentNegotiation.media(
+        "text/plain",
+        ["text/*"],
+      )
+      test
+        .expect(result)
+        .toEqual(["text/*"])
+    })
+
+    test.it("text/* does not match application/json", () => {
+      const result = ContentNegotiation.media(
+        "application/json",
+        ["text/*"],
+      )
+      test
+        .expect(result)
+        .toEqual([])
+    })
+
+    test.it("prefers exact match over wildcard available type", () => {
+      const result = ContentNegotiation.media(
+        "text/html",
+        ["text/*", "text/html"],
+      )
+      test
+        .expect(result)
+        .toEqual(["text/html", "text/*"])
+    })
+
+    test.it("text/* matches multiple text types in Accept", () => {
+      const result = ContentNegotiation.media(
+        "text/html, text/plain",
+        ["text/*"],
+      )
+      test
+        .expect(result)
+        .toEqual(["text/*"])
+    })
+
+    test.it("application/* matches application/xml", () => {
+      const result = ContentNegotiation.media(
+        "application/xml",
+        ["application/*", "text/html"],
+      )
+      test
+        .expect(result)
+        .toEqual(["application/*"])
+    })
+
+    test.it("*/* in available matches any type", () => {
+      const result = ContentNegotiation.media(
+        "image/png",
+        ["*/*"],
+      )
+      test
+        .expect(result)
+        .toEqual(["*/*"])
+    })
+
+    test.it("combines client and server wildcards", () => {
+      // Client wants text/*, server offers text/*
+      const result = ContentNegotiation.media(
+        "text/*",
+        ["text/*"],
+      )
+      test
+        .expect(result)
+        .toEqual(["text/*"])
+    })
+
+    test.it("quality values still apply with wildcard available", () => {
+      const result = ContentNegotiation.media(
+        "text/html;q=0.5, text/event-stream;q=0.9",
+        ["text/*"],
+      )
+      test
+        .expect(result)
+        .toEqual(["text/*"])
+    })
+  })
 })
 
 test.describe("ContentNegotiation.language", () => {

package/src/ContentNegotiation.ts

@@ -113,17 +113,24 @@ function specifyMediaType(
   let s = 0
 
   if (spec.type === type) {
-    s |= 4
+    s |= 4 // exact match: highest specificity
+  } else if (type === "*") {
+    s |= 0 // server offers wildcard (e.g. */*): matches any client type
   } else if (spec.type !== "*") {
+    // client is NOT requesting wildcard: no match
     return null
   }
 
+  // client requests wildcard (e.g. Accept: */*)
   if (spec.subtype === subtype) {
-    s |= 2
+    s |= 2 // // exact match: highest specificity
+  } else if (subtype === "*") {
+    s |= 1 // server offers wildcard (e.g. text/*)
   } else if (spec.subtype !== "*") {
-    return null
+    return null // client is NOT requesting wildcard
   }
 
+  // client requests wildcard (e.g. Accept: text/*): matches any server subtype
   const specParams = Object.keys(spec.params)
   if (specParams.length > 0) {
     if (

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),
+        }),
+      ),
+    ),
+  )