@effect/platform-bun 0.1.0

package/src/internal/http/server.ts

@@ -0,0 +1,263 @@
+import { pipe } from "@effect/data/Function"
+import * as Config from "@effect/io/Config"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as Runtime from "@effect/io/Runtime"
+import type * as Scope from "@effect/io/Scope"
+import * as Etag from "@effect/platform-node/Http/Etag"
+import * as FormData from "@effect/platform-node/Http/FormData"
+import type * as FileSystem from "@effect/platform/FileSystem"
+import type * as App from "@effect/platform/Http/App"
+import * as Headers from "@effect/platform/Http/Headers"
+import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
+import type { Method } from "@effect/platform/Http/Method"
+import * as Server from "@effect/platform/Http/Server"
+import * as Error from "@effect/platform/Http/ServerError"
+import * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import type * as ServerResponse from "@effect/platform/Http/ServerResponse"
+import * as UrlParams from "@effect/platform/Http/UrlParams"
+import type * as Path from "@effect/platform/Path"
+import * as Stream from "@effect/stream/Stream"
+import type { ServeOptions, Server as BunServer } from "bun"
+import { Readable } from "node:stream"
+
+/** @internal */
+export const make = (
+  options: Omit<ServeOptions, "fetch" | "error">
+): Effect.Effect<Scope.Scope, never, Server.Server> =>
+  Effect.gen(function*(_) {
+    const handlerStack: Array<(request: Request, server: BunServer) => Response | Promise<Response>> = [
+      function(_request, _server) {
+        return new Response("not found", { status: 404 })
+      }
+    ]
+    const server = Bun.serve({
+      ...options,
+      fetch: handlerStack[0]
+    })
+
+    yield* _(Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        server.stop()
+      })
+    ))
+
+    return Server.make({
+      address: { _tag: "TcpAddress", port: server.port, hostname: server.hostname },
+      serve(httpApp, middleware) {
+        const app: App.HttpApp<never, unknown, Response> = Effect.flatMap(
+          middleware ? middleware(httpApp) : httpApp,
+          respond
+        )
+        return pipe(
+          Effect.runtime<never>(),
+          Effect.flatMap((runtime) =>
+            Effect.async<never, Error.ServeError, never>(() => {
+              const runPromise = Runtime.runPromise(runtime)
+              function handler(request: Request, _server: BunServer) {
+                return runPromise(Effect.provideService(
+                  app,
+                  ServerRequest.ServerRequest,
+                  new ServerRequestImpl(request)
+                ))
+              }
+              handlerStack.push(handler)
+              server.reload({ fetch: handler } as ServeOptions)
+            })
+          ),
+          Effect.acquireRelease(() =>
+            Effect.sync(() => {
+              handlerStack.pop()
+              server.reload({ fetch: handlerStack[handlerStack.length - 1] } as ServeOptions)
+            })
+          )
+        )
+      }
+    })
+  })
+
+const respond = (response: ServerResponse.ServerResponse) =>
+  Effect.sync((): Response => {
+    const body = response.body
+    switch (body._tag) {
+      case "Empty": {
+        return new Response(undefined, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        })
+      }
+      case "Uint8Array":
+      case "Raw": {
+        return new Response(body.body as any, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        })
+      }
+      case "FormData": {
+        return new Response(body.formData, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        })
+      }
+      case "Stream": {
+        return new Response(Stream.toReadableStream(body.stream), {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        })
+      }
+    }
+  })
+
+/** @internal */
+export const layer = (
+  options: Omit<ServeOptions, "fetch" | "error">
+) =>
+  Layer.merge(
+    Layer.scoped(Server.Server, make(options)),
+    Etag.layer
+  )
+
+/** @internal */
+export const layerConfig = (
+  options: Config.Config.Wrap<Omit<ServeOptions, "fetch" | "error">>
+) =>
+  Layer.merge(
+    Layer.scoped(Server.Server, Effect.flatMap(Effect.config(Config.unwrap(options)), make)),
+    Etag.layer
+  )
+
+class ServerRequestImpl implements ServerRequest.ServerRequest {
+  readonly [ServerRequest.TypeId]: ServerRequest.TypeId
+  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
+  constructor(
+    readonly source: Request,
+    readonly url = source.url,
+    public headersOverride?: Headers.Headers
+  ) {
+    this[ServerRequest.TypeId] = ServerRequest.TypeId
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId
+  }
+  get method(): Method {
+    return this.source.method as Method
+  }
+  get originalUrl() {
+    return this.source.url
+  }
+  get headers(): Headers.Headers {
+    this.headersOverride ??= Headers.fromInput(this.source.headers)
+    return this.headersOverride
+  }
+  setUrl(url: string): ServerRequest.ServerRequest {
+    return new ServerRequestImpl(this.source, url)
+  }
+  replaceHeaders(headers: Headers.Headers): ServerRequest.ServerRequest {
+    return new ServerRequestImpl(this.source, this.url, headers)
+  }
+
+  get stream(): Stream.Stream<never, Error.RequestError, Uint8Array> {
+    return this.source.body
+      ? Stream.fromReadableStream(() => this.source.body!, (_) =>
+        Error.RequestError({
+          request: this,
+          reason: "Decode",
+          error: _
+        }))
+      : Stream.fail(Error.RequestError({
+        request: this,
+        reason: "Decode",
+        error: "can not create stream from empty body"
+      }))
+  }
+
+  private textEffect: Effect.Effect<never, Error.RequestError, string> | undefined
+  get text(): Effect.Effect<never, Error.RequestError, string> {
+    if (this.textEffect) {
+      return this.textEffect
+    }
+    this.textEffect = Effect.runSync(Effect.cached(
+      Effect.tryPromise({
+        try: () => this.source.text(),
+        catch: (error) =>
+          Error.RequestError({
+            request: this,
+            reason: "Decode",
+            error
+          })
+      })
+    ))
+    return this.textEffect
+  }
+
+  get json(): Effect.Effect<never, Error.RequestError, unknown> {
+    return Effect.tryMap(this.text, {
+      try: (_) => JSON.parse(_) as unknown,
+      catch: (error) =>
+        Error.RequestError({
+          request: this,
+          reason: "Decode",
+          error
+        })
+    })
+  }
+
+  get urlParamsBody(): Effect.Effect<never, Error.RequestError, UrlParams.UrlParams> {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: (error) =>
+          Error.RequestError({
+            request: this,
+            reason: "Decode",
+            error
+          })
+      }))
+  }
+
+  private formDataEffect:
+    | Effect.Effect<
+      Scope.Scope | FileSystem.FileSystem | Path.Path,
+      FormData.FormDataError,
+      globalThis.FormData
+    >
+    | undefined
+  get formData(): Effect.Effect<
+    Scope.Scope | FileSystem.FileSystem | Path.Path,
+    FormData.FormDataError,
+    globalThis.FormData
+  > {
+    if (this.formDataEffect) {
+      return this.formDataEffect
+    }
+    this.formDataEffect = Effect.runSync(Effect.cached(
+      FormData.formData(Readable.fromWeb(this.source.body!), this.headers)
+    ))
+    return this.formDataEffect
+  }
+
+  get formDataStream(): Stream.Stream<never, FormData.FormDataError, FormData.Part> {
+    return FormData.stream(Readable.fromWeb(this.source.body!), this.headers)
+  }
+
+  private arrayBufferEffect: Effect.Effect<never, Error.RequestError, ArrayBuffer> | undefined
+  get arrayBuffer(): Effect.Effect<never, Error.RequestError, ArrayBuffer> {
+    if (this.arrayBuffer) {
+      return this.arrayBuffer
+    }
+    this.arrayBufferEffect = Effect.runSync(Effect.cached(
+      Effect.tryPromise({
+        try: () => this.source.arrayBuffer(),
+        catch: (error) =>
+          Error.RequestError({
+            request: this,
+            reason: "Decode",
+            error
+          })
+      })
+    ))
+    return this.arrayBufferEffect
+  }
+}

package/src/internal/http/serverResponse.ts

@@ -0,0 +1,52 @@
+import { pipe } from "@effect/data/Function"
+import * as Effect from "@effect/io/Effect"
+import type * as PlatformError from "@effect/platform/Error"
+import * as FileSystem from "@effect/platform/FileSystem"
+import type * as Body from "@effect/platform/Http/Body"
+import * as Etag from "@effect/platform/Http/Etag"
+import * as ServerResponse from "@effect/platform/Http/ServerResponse"
+
+/** @internal */
+export const file = (
+  path: string,
+  options?: ServerResponse.Options.WithContentType & FileSystem.StreamOptions
+): Effect.Effect<FileSystem.FileSystem | Etag.Generator, PlatformError.PlatformError, ServerResponse.ServerResponse> =>
+  pipe(
+    Effect.bindTo(Effect.flatMap(FileSystem.FileSystem, (fs) => fs.stat(path)), "info"),
+    Effect.bind("etag", ({ info }) =>
+      Effect.flatMap(
+        Etag.Generator,
+        (generator) => generator.fromFileInfo(info)
+      )),
+    Effect.map(({ etag, info }) => {
+      const headers: Record<string, string> = {
+        ...(options?.headers ?? {}),
+        etag: Etag.toString(etag)
+      }
+      if (info.mtime._tag === "Some") {
+        headers["last-modified"] = info.mtime.value.toUTCString()
+      }
+      let file = Bun.file(path)
+      if (options?.bytesToRead !== undefined || options?.offset !== undefined) {
+        const start = Number(options?.offset ?? 0)
+        const end = options?.bytesToRead !== undefined ? start + Number(options.bytesToRead) : undefined
+        file = file.slice(start, end)
+      }
+      return ServerResponse.raw(file, { ...options, headers })
+    })
+  )
+
+/** @internal */
+export const fileWeb = (
+  file: Body.Body.FileLike,
+  options?: ServerResponse.Options.WithContent
+): Effect.Effect<Etag.Generator, never, ServerResponse.ServerResponse> =>
+  Effect.flatMap(Etag.Generator, (generator) =>
+    Effect.map(generator.fromFileWeb(file), (etag) => {
+      const headers: Record<string, string> = {
+        ...(options?.headers ?? {}),
+        etag: Etag.toString(etag),
+        "last-modified": new Date(file.lastModified).toUTCString()
+      }
+      return ServerResponse.raw(file, { ...options, headers })
+    }))

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "build/esm",
+    "declarationDir": "build/dts",
+    "tsBuildInfoFile": "build/tsbuildinfo/esm.tsbuildinfo",
+    "rootDir": "src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*.ts"],
+  "references": [{ "path": "../platform" }, { "path": "../platform-node" }]
+}

package/tsconfig.examples.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "build/tsbuildinfo/examples.tsbuildinfo",
+    "rootDir": "examples",
+    "module": "CommonJS",
+    "outDir": "build/examples",
+    "types": ["bun-types"]
+  },
+  "include": ["examples/**/*.ts"],
+  "references": [{ "path": "./tsconfig.build.json" }]
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "build/tsbuildinfo/tsconfig.tsbuildinfo"
+  },
+  "references": [
+    { "path": "./tsconfig.build.json" },
+    { "path": "./tsconfig.test.json" },
+    { "path": "./tsconfig.examples.json" }
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "build/test",
+    "declarationDir": "build/test-dts",
+    "tsBuildInfoFile": "build/tsbuildinfo/test.tsbuildinfo",
+    "rootDir": "test",
+    "noEmit": true,
+    "types": ["vitest/globals"]
+  },
+  "include": ["test/**/*.ts"],
+  "references": [
+    {
+      "path": "./tsconfig.build.json"
+    }
+  ]
+}