imposters 0.1.0

package/src/api/ImpostersHandlers.ts

@@ -0,0 +1,387 @@
+import { HttpApiBuilder } from "@effect/platform"
+import * as Clock from "effect/Clock"
+import * as DateTime from "effect/DateTime"
+import * as Effect from "effect/Effect"
+import { ImposterConfig, type ProxyConfigDomain } from "../domain/imposter"
+import { ImposterRepository } from "../repositories/ImposterRepository"
+import { NonEmptyString } from "../schemas/common"
+import { ImposterServer } from "../server/ImposterServer"
+import { AppConfig } from "../services/AppConfig"
+import { MetricsService } from "../services/MetricsService"
+import { PortAllocator } from "../services/PortAllocator"
+import { RequestLogger } from "../services/RequestLogger"
+import { Uuid } from "../services/Uuid"
+import { AdminApi } from "./AdminApi"
+import { ApiConflictError, ApiNotFoundError, ApiServiceError } from "./ApiErrors"
+import { buildPaginationMeta, toImposterResponse } from "./Conversions"
+
+export const ImpostersHandlersLive = HttpApiBuilder.group(AdminApi, "imposters", (handlers) =>
+  handlers
+    .handle("createImposter", ({ payload }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const uuid = yield* Uuid
+        const allocator = yield* PortAllocator
+        const config = yield* AppConfig
+
+        const all = yield* repo.getAll
+        if (all.length >= config.maxImposters) {
+          return yield* Effect.fail(
+            new ApiServiceError({ message: `Maximum number of imposters (${config.maxImposters}) reached` })
+          )
+        }
+
+        const id = yield* uuid.generateShort
+        const name = payload.name ?? NonEmptyString.make(id)
+
+        const port = yield* allocator.allocate(payload.port).pipe(
+          Effect.catchTags({
+            PortAllocatorError: (e) => Effect.fail(new ApiConflictError({ message: e.reason })),
+            PortExhaustedError: (e) =>
+              Effect.fail(new ApiServiceError({ message: `No available ports in range ${e.rangeMin}-${e.rangeMax}` }))
+          })
+        )
+
+        const imposterConfig = ImposterConfig({
+          id,
+          name,
+          port,
+          status: "stopped",
+          createdAt: DateTime.unsafeNow(),
+          ...(payload.proxy !== undefined ? { proxy: payload.proxy } : {})
+        })
+
+        const record = yield* repo.create(imposterConfig)
+        return yield* toImposterResponse(record)
+      }))
+    .handle("listImposters", ({ urlParams }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const all = yield* repo.getAll
+
+        // All imposters are HTTP in Phase 2; protocol filter is for forward compatibility
+        const filtered = all
+          .filter((r) => urlParams.status === undefined || r.config.status === urlParams.status)
+          .filter(() => urlParams.protocol === undefined || urlParams.protocol === "HTTP")
+
+        filtered.sort((a, b) => DateTime.toEpochMillis(a.config.createdAt) - DateTime.toEpochMillis(b.config.createdAt))
+
+        const total = filtered.length
+        const paged = filtered.slice(urlParams.offset, urlParams.offset + urlParams.limit)
+        const imposters = yield* Effect.all(paged.map(toImposterResponse))
+
+        return {
+          imposters,
+          pagination: buildPaginationMeta(total, urlParams.limit, urlParams.offset)
+        }
+      }))
+    .handle("getImposter", ({ path }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const record = yield* repo.get(path.id).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+        return yield* toImposterResponse(record)
+      }))
+    .handle("updateImposter", ({ path, payload }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const allocator = yield* PortAllocator
+        const imposterServer = yield* ImposterServer
+
+        const existing = yield* repo.get(path.id).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+
+        const wasRunning = yield* imposterServer.isRunning(path.id)
+        const wantsRunning = payload.status === "running"
+        const wantsStopped = payload.status === "stopped"
+        const portChanging = payload.port !== undefined && payload.port !== existing.config.port
+
+        // If port is changing while running, stop first
+        if (portChanging && wasRunning) {
+          yield* imposterServer.stop(path.id)
+        }
+
+        let newPort: number | undefined
+        if (portChanging) {
+          newPort = yield* allocator.allocate(payload.port).pipe(
+            Effect.catchTags({
+              PortAllocatorError: (e) => Effect.fail(new ApiConflictError({ message: e.reason })),
+              PortExhaustedError: (e) =>
+                Effect.fail(new ApiServiceError({ message: `No available ports in range ${e.rangeMin}-${e.rangeMax}` }))
+            })
+          )
+        }
+
+        // Compute proxy update: undefined = no change, null = remove, object = set
+        const proxyUpdate: { proxy?: ProxyConfigDomain | undefined } = payload.proxy === undefined
+          ? {}
+          : payload.proxy === null
+          ? { proxy: undefined }
+          : { proxy: payload.proxy }
+
+        yield* repo.update(path.id, (r) => ({
+          ...r,
+          config: ImposterConfig({
+            ...r.config,
+            ...(payload.name !== undefined ? { name: payload.name as string } : {}),
+            ...(payload.status !== undefined ? { status: payload.status } : {}),
+            ...(newPort !== undefined ? { port: newPort } : {}),
+            ...proxyUpdate
+          })
+        })).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            )),
+          Effect.tapError(() => newPort !== undefined ? allocator.release(newPort) : Effect.void)
+        )
+
+        if (newPort !== undefined) {
+          yield* allocator.release(existing.config.port)
+        }
+
+        // Hot-reload proxy config if it changed
+        if (payload.proxy !== undefined) {
+          yield* imposterServer.updateProxyConfig(path.id)
+        }
+
+        // Handle start/stop transitions
+        if (wantsRunning && !wasRunning) {
+          yield* imposterServer.start(path.id).pipe(
+            Effect.catchTag("ImposterServerError", (e) => Effect.fail(new ApiServiceError({ message: e.reason }))),
+            Effect.catchTag("ImposterNotFoundError", (e) =>
+              Effect.fail(
+                new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+              ))
+          )
+        } else if (wantsStopped && wasRunning && !portChanging) {
+          yield* imposterServer.stop(path.id)
+        } else if (portChanging && wasRunning) {
+          // Port changed while running — restart
+          yield* imposterServer.start(path.id).pipe(
+            Effect.catchTag("ImposterServerError", (e) => Effect.fail(new ApiServiceError({ message: e.reason }))),
+            Effect.catchTag("ImposterNotFoundError", (e) =>
+              Effect.fail(
+                new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+              ))
+          )
+        }
+
+        // Re-read to get final status
+        const final = yield* repo.get(path.id).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+        return yield* toImposterResponse(final)
+      }))
+    .handle("deleteImposter", ({ path, urlParams }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const allocator = yield* PortAllocator
+        const imposterServer = yield* ImposterServer
+        const metricsService = yield* MetricsService
+
+        const existing = yield* repo.get(path.id).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+
+        if (!urlParams.force && existing.config.status !== "stopped") {
+          return yield* Effect.fail(
+            new ApiConflictError({
+              message: `Imposter is ${existing.config.status}, use force=true to delete`
+            })
+          )
+        }
+
+        // Stop if running
+        const running = yield* imposterServer.isRunning(path.id)
+        if (running) {
+          yield* imposterServer.stop(path.id)
+        }
+
+        yield* repo.remove(path.id).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+        yield* allocator.release(existing.config.port)
+        yield* metricsService.resetStats(path.id)
+
+        const now = yield* Effect.map(Clock.currentTimeMillis, (ms) => DateTime.unsafeMake(ms))
+
+        return {
+          message: NonEmptyString.make(`Imposter ${path.id} deleted`),
+          id: NonEmptyString.make(path.id),
+          deletedAt: now
+        }
+      }))
+    .handle("addStub", ({ path, payload }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const uuid = yield* Uuid
+        const imposterServer = yield* ImposterServer
+
+        const id = yield* uuid.generateShort
+        const stub = {
+          id: NonEmptyString.make(id),
+          predicates: payload.predicates,
+          responses: payload.responses,
+          responseMode: payload.responseMode
+        }
+
+        const result = yield* repo.addStub(path.imposterId, stub).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+
+        // Hot-reload if running
+        const running = yield* imposterServer.isRunning(path.imposterId)
+        if (running) {
+          yield* imposterServer.updateStubs(path.imposterId)
+        }
+
+        return result
+      }))
+    .handle("listStubs", ({ path }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        return yield* repo.getStubs(path.imposterId).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+      }))
+    .handle("updateStub", ({ path, payload }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const imposterServer = yield* ImposterServer
+
+        const result = yield* repo.updateStub(path.imposterId, path.stubId, (s) => ({
+          ...s,
+          ...(payload.predicates !== undefined ? { predicates: payload.predicates } : {}),
+          ...(payload.responses !== undefined ? { responses: payload.responses } : {}),
+          ...(payload.responseMode !== undefined ? { responseMode: payload.responseMode } : {})
+        })).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            )),
+          Effect.catchTag("StubNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Stub not found", resourceType: "stub", resourceId: e.stubId })
+            ))
+        )
+
+        // Hot-reload if running
+        const running = yield* imposterServer.isRunning(path.imposterId)
+        if (running) {
+          yield* imposterServer.updateStubs(path.imposterId)
+        }
+
+        return result
+      }))
+    .handle("deleteStub", ({ path }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const imposterServer = yield* ImposterServer
+
+        const result = yield* repo.removeStub(path.imposterId, path.stubId).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            )),
+          Effect.catchTag(
+            "StubNotFoundError",
+            (e) =>
+              Effect.fail(
+                new ApiNotFoundError({ message: "Stub not found", resourceType: "stub", resourceId: e.stubId })
+              )
+          )
+        )
+
+        // Hot-reload if running
+        const running = yield* imposterServer.isRunning(path.imposterId)
+        if (running) {
+          yield* imposterServer.updateStubs(path.imposterId)
+        }
+
+        return result
+      }))
+    .handle("listRequests", ({ path, urlParams }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const requestLogger = yield* RequestLogger
+        yield* repo.get(path.id).pipe(
+          Effect.catchTag(
+            "ImposterNotFoundError",
+            (e) =>
+              Effect.fail(
+                new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+              )
+          )
+        )
+        return yield* requestLogger.getEntries(path.id, {
+          limit: urlParams.limit,
+          ...(urlParams.method !== undefined ? { method: urlParams.method } : {}),
+          ...(urlParams.path !== undefined ? { path: urlParams.path } : {}),
+          ...(urlParams.status !== undefined ? { status: urlParams.status } : {})
+        })
+      }))
+    .handle("clearRequests", ({ path }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const requestLogger = yield* RequestLogger
+        yield* repo.get(path.id).pipe(
+          Effect.catchTag(
+            "ImposterNotFoundError",
+            (e) =>
+              Effect.fail(
+                new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+              )
+          )
+        )
+        yield* requestLogger.clear(path.id)
+        return { message: `Request log cleared for imposter ${path.id}` }
+      }))
+    .handle("getImposterStats", ({ path }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const metricsService = yield* MetricsService
+        yield* repo.get(path.id).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+        return yield* metricsService.getStats(path.id)
+      }))
+    .handle("resetImposterStats", ({ path }) =>
+      Effect.gen(function*() {
+        const repo = yield* ImposterRepository
+        const metricsService = yield* MetricsService
+        yield* repo.get(path.id).pipe(
+          Effect.catchTag("ImposterNotFoundError", (e) =>
+            Effect.fail(
+              new ApiNotFoundError({ message: "Imposter not found", resourceType: "imposter", resourceId: e.id })
+            ))
+        )
+        yield* metricsService.resetStats(path.id)
+        return { message: `Statistics reset for imposter ${path.id}` }
+      })))

package/src/api/SystemGroup.ts

@@ -0,0 +1,12 @@
+import { HttpApiEndpoint, HttpApiGroup } from "@effect/platform"
+import { HealthResponse, ServerInfoResponse } from "../schemas/ImposterSchema"
+
+export const SystemGroup = HttpApiGroup.make("system", { topLevel: true })
+  .add(
+    HttpApiEndpoint.get("healthCheck", "/health")
+      .addSuccess(HealthResponse)
+  )
+  .add(
+    HttpApiEndpoint.get("serverInfo", "/info")
+      .addSuccess(ServerInfoResponse)
+  )

package/src/api/SystemHandlers.ts

@@ -0,0 +1,76 @@
+import { HttpApiBuilder } from "@effect/platform"
+import * as Clock from "effect/Clock"
+import * as DateTime from "effect/DateTime"
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import { ImposterRepository } from "../repositories/ImposterRepository"
+import { NonEmptyString, PortNumber } from "../schemas/common"
+import { AppConfig } from "../services/AppConfig"
+import { AdminApi } from "./AdminApi"
+
+export const SystemHandlersLive = HttpApiBuilder.group(AdminApi, "system", (handlers) =>
+  handlers
+    .handle("healthCheck", () =>
+      Effect.gen(function*() {
+        const config = yield* AppConfig
+        const repo = yield* ImposterRepository
+        const all = yield* repo.getAll
+
+        const now = yield* Effect.map(Clock.currentTimeMillis, (ms) => DateTime.unsafeMake(ms))
+        const memUsage = process.memoryUsage()
+
+        const running = all.filter((r) => r.config.status === "running").length
+        const stopped = all.filter((r) => r.config.status === "stopped").length
+
+        return {
+          status: "healthy" as const,
+          timestamp: now,
+          version: NonEmptyString.make("0.0.0"),
+          uptime: Duration.format(Duration.millis(process.uptime() * 1000)),
+          system: {
+            memory: {
+              used: NonEmptyString.make(`${Math.round(memUsage.heapUsed / 1024 / 1024)}MB`),
+              free: NonEmptyString.make(`${Math.round((memUsage.heapTotal - memUsage.heapUsed) / 1024 / 1024)}MB`)
+            },
+            imposters: {
+              total: all.length,
+              running,
+              stopped
+            },
+            ports: {
+              available: config.portRangeMax - config.portRangeMin + 1 - all.length,
+              allocated: all.length
+            }
+          }
+        }
+      }))
+    .handle("serverInfo", () =>
+      Effect.gen(function*() {
+        const config = yield* AppConfig
+        const now = yield* Effect.map(Clock.currentTimeMillis, (ms) => DateTime.unsafeMake(ms))
+
+        return {
+          server: {
+            name: NonEmptyString.make("imposters"),
+            version: NonEmptyString.make("0.0.0"),
+            buildTime: now,
+            platform: NonEmptyString.make(process.platform),
+            protocols: ["HTTP" as const]
+          },
+          configuration: {
+            maxImposters: config.maxImposters,
+            portRange: {
+              min: PortNumber.make(config.portRangeMin),
+              max: PortNumber.make(config.portRangeMax)
+            },
+            defaultTimeout: 30000,
+            logLevel: config.logLevel
+          },
+          features: {
+            openApiGeneration: true,
+            clientGeneration: false,
+            authentication: false,
+            clustering: false
+          }
+        }
+      })))

package/src/cli/Commands.ts

@@ -0,0 +1,119 @@
+import { Command, Options } from "@effect/cli"
+import { NodeContext, NodeRuntime } from "@effect/platform-node"
+import { Effect, Layer, Option } from "effect"
+import { HandlerHttpClientLive } from "../client/HandlerHttpClient"
+import { ImpostersClient, ImpostersClientLive } from "../client/ImpostersClient"
+import { makeCompositeHandler } from "../server/AdminServer"
+import { loadConfigFile } from "./ConfigLoader"
+
+const configOption = Options.file("config").pipe(
+  Options.withAlias("c"),
+  Options.withDescription("Path to JSON config file"),
+  Options.optional
+)
+
+const portOption = Options.integer("port").pipe(
+  Options.withAlias("p"),
+  Options.withDescription("Admin server port (default: 2525)"),
+  Options.optional
+)
+
+const startCommand = Command.make(
+  "start",
+  { config: configOption, port: portOption },
+  ({ config, port }) =>
+    Effect.gen(function*() {
+      const adminPort = Option.isSome(port) ? port.value : Number(process.env.ADMIN_PORT ?? 2525)
+
+      const { dispose, handler } = makeCompositeHandler(adminPort)
+      const server = Bun.serve({ port: adminPort, fetch: handler })
+
+      console.log(`Imposters admin server running on http://localhost:${server.port}`)
+      console.log(`Admin UI: http://localhost:${server.port}/_ui`)
+
+      // Load config and create imposters if config file provided
+      if (Option.isSome(config)) {
+        const configData = yield* loadConfigFile(config.value).pipe(
+          Effect.catchTag("ConfigLoadError", (e) =>
+            Effect.sync(() => {
+              console.error(`Warning: ${e.message}`)
+              return null
+            }))
+        )
+
+        if (configData !== null && configData.imposters.length > 0) {
+          const clientLayer = ImpostersClientLive(`http://localhost:${server.port}`).pipe(
+            Layer.provide(HandlerHttpClientLive(handler))
+          )
+
+          yield* Effect.provide(
+            Effect.gen(function*() {
+              const client = yield* ImpostersClient
+              for (const imp of configData.imposters) {
+                const created = yield* client.imposters.createImposter({
+                  payload: {
+                    port: imp.port,
+                    ...(imp.name !== undefined ? { name: imp.name } : {}),
+                    protocol: "HTTP" as const,
+                    adminPath: "/_admin"
+                  }
+                }).pipe(Effect.catchAll((e) => {
+                  console.error(`Failed to create imposter on port ${imp.port}: ${e}`)
+                  return Effect.succeed(null)
+                }))
+
+                if (created === null) continue
+
+                for (const stub of imp.stubs) {
+                  yield* client.imposters.addStub({
+                    path: { imposterId: created.id },
+                    payload: stub
+                  }).pipe(Effect.catchAll((e) => {
+                    console.error(`Failed to add stub: ${e}`)
+                    return Effect.void
+                  }))
+                }
+
+                yield* client.imposters.updateImposter({
+                  path: { id: created.id },
+                  payload: { status: "running" as const }
+                }).pipe(Effect.catchAll((e) => {
+                  console.error(`Failed to start imposter ${created.id}: ${e}`)
+                  return Effect.void
+                }))
+
+                console.log(`Created imposter "${imp.name ?? created.id}" on port ${imp.port}`)
+              }
+            }),
+            clientLayer
+          )
+        }
+      }
+
+      // Keep running until interrupted
+      yield* Effect.async<never, never>(() => {
+        const shutdown = () => {
+          console.log("Shutting down...")
+          server.stop(true)
+          dispose()
+          process.exit(0)
+        }
+        process.on("SIGINT", shutdown)
+        process.on("SIGTERM", shutdown)
+      })
+    })
+)
+
+const command = Command.make("imposters").pipe(
+  Command.withSubcommands([startCommand])
+)
+
+export const run = Command.run(command, {
+  name: "imposters",
+  version: "0.1.0"
+})
+
+export const main = run(process.argv).pipe(
+  Effect.provide(NodeContext.layer),
+  NodeRuntime.runMain
+)

package/src/cli/ConfigLoader.ts

@@ -0,0 +1,41 @@
+import { Data, Effect, Schema } from "effect"
+import * as fs from "node:fs"
+import { ConfigFile } from "../schemas/ConfigFileSchema"
+
+export class ConfigLoadError extends Data.TaggedError("ConfigLoadError")<{
+  readonly message: string
+  readonly cause?: unknown
+}> {}
+
+export const loadConfigFile = (
+  filePath: string
+): Effect.Effect<Schema.Schema.Type<typeof ConfigFile>, ConfigLoadError> =>
+  Effect.gen(function*() {
+    const content = yield* Effect.try({
+      try: () => fs.readFileSync(filePath, "utf-8"),
+      catch: (error) =>
+        new ConfigLoadError({
+          message: `Failed to read config file: ${filePath}`,
+          cause: error
+        })
+    })
+
+    const json = yield* Effect.try({
+      try: () => JSON.parse(content) as unknown,
+      catch: (error) =>
+        new ConfigLoadError({
+          message: `Invalid JSON in config file: ${filePath}`,
+          cause: error
+        })
+    })
+
+    return yield* Schema.decodeUnknown(ConfigFile)(json).pipe(
+      Effect.mapError(
+        (error) =>
+          new ConfigLoadError({
+            message: `Config validation failed: ${String(error)}`,
+            cause: error
+          })
+      )
+    )
+  })

package/src/client/HandlerHttpClient.ts

@@ -0,0 +1,50 @@
+import { HttpClient, HttpClientResponse } from "@effect/platform"
+import { Effect, Layer } from "effect"
+
+export const makeHandlerHttpClient = (
+  handler: (request: Request) => Promise<Response>
+): HttpClient.HttpClient =>
+  HttpClient.make((request, url) =>
+    Effect.tryPromise({
+      try: async () => {
+        const method = request.method
+        const headers: Record<string, string> = {}
+        for (const key of Object.keys(request.headers)) {
+          headers[key] = request.headers[key]!
+        }
+
+        let body: BodyInit | undefined
+        switch (request.body._tag) {
+          case "Uint8Array":
+            body = new globalThis.Uint8Array(request.body.body)
+            break
+          case "Raw": {
+            const raw = request.body.body
+            body = typeof raw === "string" ? raw : JSON.stringify(raw)
+            break
+          }
+          case "Empty":
+            body = undefined
+            break
+          default:
+            body = undefined
+        }
+
+        const webRequest = new Request(url.toString(), {
+          method,
+          headers,
+          ...(body !== undefined ? { body } : {})
+        })
+
+        const webResponse = await handler(webRequest)
+        return HttpClientResponse.fromWeb(request, webResponse)
+      },
+      catch: (error) => {
+        throw error
+      }
+    })
+  )
+
+export const HandlerHttpClientLive = (
+  handler: (request: Request) => Promise<Response>
+): Layer.Layer<HttpClient.HttpClient> => Layer.succeed(HttpClient.HttpClient, makeHandlerHttpClient(handler))