@effect/platform-node 0.104.1 → 4.0.0-beta.0

package/src/internal/httpClient.ts

@@ -1,260 +0,0 @@
-import * as Cookies from "@effect/platform/Cookies"
-import type * as Body from "@effect/platform/HttpBody"
-import * as Client from "@effect/platform/HttpClient"
-import * as Error from "@effect/platform/HttpClientError"
-import type * as ClientRequest from "@effect/platform/HttpClientRequest"
-import * as ClientResponse from "@effect/platform/HttpClientResponse"
-import * as IncomingMessage from "@effect/platform/HttpIncomingMessage"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Layer from "effect/Layer"
-import type * as Scope from "effect/Scope"
-import * as Stream from "effect/Stream"
-import * as Http from "node:http"
-import * as Https from "node:https"
-import { Readable } from "node:stream"
-import { pipeline } from "node:stream/promises"
-import type * as NodeClient from "../NodeHttpClient.js"
-import * as NodeSink from "../NodeSink.js"
-import { HttpIncomingMessageImpl } from "./httpIncomingMessage.js"
-
-/** @internal */
-export const HttpAgentTypeId: NodeClient.HttpAgentTypeId = Symbol.for(
-  "@effect/platform-node/Http/NodeClient/HttpAgent"
-) as NodeClient.HttpAgentTypeId
-
-/** @internal */
-export const HttpAgent = Context.GenericTag<NodeClient.HttpAgent>("@effect/platform-node/Http/NodeClient/HttpAgent")
-
-/** @internal */
-export const makeAgent = (options?: Https.AgentOptions): Effect.Effect<NodeClient.HttpAgent, never, Scope.Scope> =>
-  Effect.map(
-    Effect.all([
-      Effect.acquireRelease(
-        Effect.sync(() => new Http.Agent(options)),
-        (agent) => Effect.sync(() => agent.destroy())
-      ),
-      Effect.acquireRelease(
-        Effect.sync(() => new Https.Agent(options)),
-        (agent) => Effect.sync(() => agent.destroy())
-      )
-    ]),
-    ([http, https]) => ({
-      [HttpAgentTypeId]: HttpAgentTypeId,
-      http,
-      https
-    })
-  )
-
-/** @internal */
-export const makeAgentLayer = (options?: Https.AgentOptions): Layer.Layer<NodeClient.HttpAgent> =>
-  Layer.scoped(HttpAgent, makeAgent(options))
-
-/** @internal */
-export const agentLayer = makeAgentLayer()
-
-const fromAgent = (agent: NodeClient.HttpAgent): Client.HttpClient =>
-  Client.make((request, url, signal) => {
-    const nodeRequest = url.protocol === "https:" ?
-      Https.request(url, {
-        agent: agent.https,
-        method: request.method,
-        headers: request.headers,
-        signal
-      }) :
-      Http.request(url, {
-        agent: agent.http,
-        method: request.method,
-        headers: request.headers,
-        signal
-      })
-    return pipe(
-      Effect.zipRight(sendBody(nodeRequest, request, request.body), waitForResponse(nodeRequest, request), {
-        concurrent: true
-      }),
-      Effect.map((_) => new ClientResponseImpl(request, _))
-    )
-  })
-
-const sendBody = (
-  nodeRequest: Http.ClientRequest,
-  request: ClientRequest.HttpClientRequest,
-  body: Body.HttpBody
-): Effect.Effect<void, Error.RequestError> =>
-  Effect.suspend((): Effect.Effect<void, Error.RequestError> => {
-    switch (body._tag) {
-      case "Empty": {
-        nodeRequest.end()
-        return waitForFinish(nodeRequest, request)
-      }
-      case "Uint8Array":
-      case "Raw": {
-        nodeRequest.end(body.body)
-        return waitForFinish(nodeRequest, request)
-      }
-      case "FormData": {
-        const response = new Response(body.formData)
-
-        response.headers.forEach((value, key) => {
-          nodeRequest.setHeader(key, value)
-        })
-
-        return Effect.tryPromise({
-          try: () => pipeline(Readable.fromWeb(response.body! as any), nodeRequest),
-          catch: (cause) =>
-            new Error.RequestError({
-              request,
-              reason: "Transport",
-              cause
-            })
-        })
-      }
-      case "Stream": {
-        return Stream.run(
-          Stream.mapError(body.stream, (cause) =>
-            new Error.RequestError({
-              request,
-              reason: "Encode",
-              cause
-            })),
-          NodeSink.fromWritable(() => nodeRequest, (cause) =>
-            new Error.RequestError({
-              request,
-              reason: "Transport",
-              cause
-            }))
-        )
-      }
-    }
-  })
-
-const waitForResponse = (nodeRequest: Http.ClientRequest, request: ClientRequest.HttpClientRequest) =>
-  Effect.async<Http.IncomingMessage, Error.RequestError>((resume) => {
-    function onError(cause: Error) {
-      resume(Effect.fail(
-        new Error.RequestError({
-          request,
-          reason: "Transport",
-          cause
-        })
-      ))
-    }
-    nodeRequest.on("error", onError)
-
-    function onResponse(response: Http.IncomingMessage) {
-      nodeRequest.off("error", onError)
-      resume(Effect.succeed(response))
-    }
-    nodeRequest.on("upgrade", onResponse)
-    nodeRequest.on("response", onResponse)
-
-    return Effect.sync(() => {
-      nodeRequest.off("error", onError)
-      nodeRequest.off("upgrade", onResponse)
-      nodeRequest.off("response", onResponse)
-    })
-  })
-
-const waitForFinish = (nodeRequest: Http.ClientRequest, request: ClientRequest.HttpClientRequest) =>
-  Effect.async<void, Error.RequestError>((resume) => {
-    function onError(cause: Error) {
-      resume(Effect.fail(
-        new Error.RequestError({
-          request,
-          reason: "Transport",
-          cause
-        })
-      ))
-    }
-    nodeRequest.once("error", onError)
-
-    function onFinish() {
-      nodeRequest.off("error", onError)
-      resume(Effect.void)
-    }
-    nodeRequest.once("finish", onFinish)
-
-    return Effect.sync(() => {
-      nodeRequest.off("error", onError)
-      nodeRequest.off("finish", onFinish)
-    })
-  })
-
-class ClientResponseImpl extends HttpIncomingMessageImpl<Error.ResponseError>
-  implements ClientResponse.HttpClientResponse
-{
-  readonly [ClientResponse.TypeId]: ClientResponse.TypeId
-
-  constructor(
-    readonly request: ClientRequest.HttpClientRequest,
-    source: Http.IncomingMessage
-  ) {
-    super(source, (cause) =>
-      new Error.ResponseError({
-        request,
-        response: this,
-        reason: "Decode",
-        cause
-      }))
-    this[ClientResponse.TypeId] = ClientResponse.TypeId
-  }
-
-  get status() {
-    return this.source.statusCode!
-  }
-
-  cachedCookies?: Cookies.Cookies
-  get cookies(): Cookies.Cookies {
-    if (this.cachedCookies !== undefined) {
-      return this.cachedCookies
-    }
-    const header = this.source.headers["set-cookie"]
-    if (Array.isArray(header)) {
-      return this.cachedCookies = Cookies.fromSetCookie(header)
-    }
-    return this.cachedCookies = Cookies.empty
-  }
-
-  get formData(): Effect.Effect<FormData, Error.ResponseError> {
-    return Effect.tryPromise({
-      try: () => {
-        const init: {
-          headers: HeadersInit
-          status?: number
-          statusText?: string
-        } = {
-          headers: new globalThis.Headers(this.source.headers as any)
-        }
-
-        if (this.source.statusCode) {
-          init.status = this.source.statusCode
-        }
-
-        if (this.source.statusMessage) {
-          init.statusText = this.source.statusMessage
-        }
-
-        return new Response(Readable.toWeb(this.source) as any, init).formData()
-      },
-      catch: this.onError
-    })
-  }
-
-  toJSON(): unknown {
-    return IncomingMessage.inspect(this, {
-      _id: "@effect/platform/HttpClientResponse",
-      request: this.request.toJSON(),
-      status: this.status
-    })
-  }
-}
-
-/** @internal */
-export const make = Effect.map(HttpAgent, fromAgent)
-
-/** @internal */
-export const layerWithoutAgent = Client.layerMergedContext(make)
-
-/** @internal */
-export const layer = Layer.provide(layerWithoutAgent, agentLayer)

package/src/internal/httpClientUndici.ts

@@ -1,231 +0,0 @@
-import * as Cookies from "@effect/platform/Cookies"
-import * as Headers from "@effect/platform/Headers"
-import type * as Body from "@effect/platform/HttpBody"
-import * as Client from "@effect/platform/HttpClient"
-import * as Error from "@effect/platform/HttpClientError"
-import type * as ClientRequest from "@effect/platform/HttpClientRequest"
-import * as ClientResponse from "@effect/platform/HttpClientResponse"
-import * as IncomingMessage from "@effect/platform/HttpIncomingMessage"
-import * as UrlParams from "@effect/platform/UrlParams"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as FiberRef from "effect/FiberRef"
-import * as Inspectable from "effect/Inspectable"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import type * as Scope from "effect/Scope"
-import type * as Stream from "effect/Stream"
-import type * as NodeClient from "../NodeHttpClient.js"
-import * as NodeStream from "../NodeStream.js"
-import * as Undici from "../Undici.js"
-
-/** @internal */
-export const Dispatcher = Context.GenericTag<NodeClient.Dispatcher, Undici.Dispatcher>(
-  "@effect/platform-node/NodeHttpClient/Dispatcher"
-)
-
-/** @internal */
-export const makeDispatcher: Effect.Effect<Undici.Dispatcher, never, Scope.Scope> = Effect.acquireRelease(
-  Effect.sync(() => new Undici.Agent()),
-  (dispatcher) => Effect.promise(() => dispatcher.destroy())
-)
-
-/** @internal */
-export const dispatcherLayer = Layer.scoped(Dispatcher, makeDispatcher)
-
-/** @internal */
-export const dispatcherLayerGlobal = Layer.sync(Dispatcher, () => Undici.getGlobalDispatcher())
-
-/** @internal */
-export const undiciOptionsTagKey = "@effect/platform-node/NodeHttpClient/undiciOptions"
-
-/** @internal */
-export const make = (dispatcher: Undici.Dispatcher): Client.HttpClient =>
-  Client.make((request, url, signal, fiber) => {
-    const context = fiber.getFiberRef(FiberRef.currentContext)
-    const options: Undici.Dispatcher.RequestOptions = context.unsafeMap.get(undiciOptionsTagKey) ?? {}
-    return convertBody(request.body).pipe(
-      Effect.flatMap((body) =>
-        Effect.tryPromise({
-          try: () =>
-            dispatcher.request({
-              ...options,
-              signal,
-              method: request.method,
-              headers: request.headers,
-              origin: url.origin,
-              path: url.pathname + url.search + url.hash,
-              body,
-              // leave timeouts to Effect.timeout etc
-              headersTimeout: 60 * 60 * 1000,
-              bodyTimeout: 0
-            }),
-          catch: (cause) =>
-            new Error.RequestError({
-              request,
-              reason: "Transport",
-              cause
-            })
-        })
-      ),
-      Effect.map((response) => new ClientResponseImpl(request, response))
-    )
-  })
-
-function convertBody(
-  body: Body.HttpBody
-): Effect.Effect<Exclude<Undici.Dispatcher.DispatchOptions["body"], undefined>> {
-  switch (body._tag) {
-    case "Empty": {
-      return Effect.succeed(null)
-    }
-    case "Uint8Array":
-    case "Raw": {
-      return Effect.succeed(body.body as Uint8Array)
-    }
-    case "FormData": {
-      return Effect.succeed(body.formData as Undici.FormData)
-    }
-    case "Stream": {
-      return NodeStream.toReadable(body.stream)
-    }
-  }
-}
-
-function noopErrorHandler(_: any) {}
-
-class ClientResponseImpl extends Inspectable.Class implements ClientResponse.HttpClientResponse {
-  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
-  readonly [ClientResponse.TypeId]: ClientResponse.TypeId
-
-  constructor(
-    readonly request: ClientRequest.HttpClientRequest,
-    readonly source: Undici.Dispatcher.ResponseData
-  ) {
-    super()
-    this[IncomingMessage.TypeId] = IncomingMessage.TypeId
-    this[ClientResponse.TypeId] = ClientResponse.TypeId
-    source.body.on("error", noopErrorHandler)
-  }
-
-  get status() {
-    return this.source.statusCode!
-  }
-
-  get statusText() {
-    return undefined
-  }
-
-  cachedCookies?: Cookies.Cookies
-  get cookies(): Cookies.Cookies {
-    if (this.cachedCookies !== undefined) {
-      return this.cachedCookies
-    }
-    const header = this.source.headers["set-cookie"]
-    if (header !== undefined) {
-      return this.cachedCookies = Cookies.fromSetCookie(Array.isArray(header) ? header : [header])
-    }
-    return this.cachedCookies = Cookies.empty
-  }
-
-  get headers(): Headers.Headers {
-    return Headers.fromInput(this.source.headers)
-  }
-
-  get remoteAddress(): Option.Option<string> {
-    return Option.none()
-  }
-
-  get stream(): Stream.Stream<Uint8Array, Error.ResponseError> {
-    return NodeStream.fromReadable(() => this.source.body, (cause) =>
-      new Error.ResponseError({
-        request: this.request,
-        response: this,
-        reason: "Decode",
-        cause
-      }))
-  }
-
-  get json(): Effect.Effect<unknown, Error.ResponseError> {
-    return Effect.tryMap(this.text, {
-      try: (text) => text === "" ? null : JSON.parse(text) as unknown,
-      catch: (cause) =>
-        new Error.ResponseError({
-          request: this.request,
-          response: this,
-          reason: "Decode",
-          cause
-        })
-    })
-  }
-
-  private textBody?: Effect.Effect<string, Error.ResponseError>
-  get text(): Effect.Effect<string, Error.ResponseError> {
-    return this.textBody ??= Effect.tryPromise({
-      try: () => this.source.body.text(),
-      catch: (cause) =>
-        new Error.ResponseError({
-          request: this.request,
-          response: this,
-          reason: "Decode",
-          cause
-        })
-    }).pipe(Effect.cached, Effect.runSync)
-  }
-
-  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, Error.ResponseError> {
-    return Effect.flatMap(this.text, (_) =>
-      Effect.try({
-        try: () => UrlParams.fromInput(new URLSearchParams(_)),
-        catch: (cause) =>
-          new Error.ResponseError({
-            request: this.request,
-            response: this,
-            reason: "Decode",
-            cause
-          })
-      }))
-  }
-
-  private formDataBody?: Effect.Effect<FormData, Error.ResponseError>
-  get formData(): Effect.Effect<FormData, Error.ResponseError> {
-    return this.formDataBody ??= Effect.tryPromise({
-      try: () => this.source.body.formData() as Promise<FormData>,
-      catch: (cause) =>
-        new Error.ResponseError({
-          request: this.request,
-          response: this,
-          reason: "Decode",
-          cause
-        })
-    }).pipe(Effect.cached, Effect.runSync)
-  }
-
-  private arrayBufferBody?: Effect.Effect<ArrayBuffer, Error.ResponseError>
-  get arrayBuffer(): Effect.Effect<ArrayBuffer, Error.ResponseError> {
-    return this.arrayBufferBody ??= Effect.tryPromise({
-      try: () => this.source.body.arrayBuffer(),
-      catch: (cause) =>
-        new Error.ResponseError({
-          request: this.request,
-          response: this,
-          reason: "Decode",
-          cause
-        })
-    }).pipe(Effect.cached, Effect.runSync)
-  }
-
-  toJSON(): unknown {
-    return IncomingMessage.inspect(this, {
-      _id: "@effect/platform/HttpClientResponse",
-      request: this.request.toJSON(),
-      status: this.status
-    })
-  }
-}
-
-/** @internal */
-export const layerWithoutDispatcher = Client.layerMergedContext(Effect.map(Dispatcher, make))
-
-/** @internal */
-export const layer = Layer.provide(layerWithoutDispatcher, dispatcherLayer)

package/src/internal/httpIncomingMessage.ts

@@ -1,92 +0,0 @@
-import * as Headers from "@effect/platform/Headers"
-import * as IncomingMessage from "@effect/platform/HttpIncomingMessage"
-import * as UrlParams from "@effect/platform/UrlParams"
-import * as Effect from "effect/Effect"
-import * as Inspectable from "effect/Inspectable"
-import * as Option from "effect/Option"
-import type * as Stream from "effect/Stream"
-import type * as Http from "node:http"
-import * as NodeStream from "../NodeStream.js"
-
-/** @internal */
-export abstract class HttpIncomingMessageImpl<E> extends Inspectable.Class
-  implements IncomingMessage.HttpIncomingMessage<E>
-{
-  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
-
-  constructor(
-    readonly source: Http.IncomingMessage,
-    readonly onError: (error: unknown) => E,
-    readonly remoteAddressOverride?: string
-  ) {
-    super()
-    this[IncomingMessage.TypeId] = IncomingMessage.TypeId
-  }
-
-  get headers() {
-    return Headers.fromInput(this.source.headers as any)
-  }
-
-  get remoteAddress() {
-    return Option.fromNullable(this.remoteAddressOverride ?? this.source.socket.remoteAddress)
-  }
-
-  private textEffect: Effect.Effect<string, E> | undefined
-  get text(): Effect.Effect<string, E> {
-    if (this.textEffect) {
-      return this.textEffect
-    }
-    this.textEffect = Effect.runSync(Effect.cached(
-      Effect.flatMap(
-        IncomingMessage.MaxBodySize,
-        (maxBodySize) =>
-          NodeStream.toString(() => this.source, {
-            onFailure: this.onError,
-            maxBytes: Option.getOrUndefined(maxBodySize)
-          })
-      )
-    ))
-    return this.textEffect
-  }
-
-  get unsafeText(): string {
-    return Effect.runSync(this.text)
-  }
-
-  get json(): Effect.Effect<unknown, E> {
-    return Effect.tryMap(this.text, {
-      try: (_) => _ === "" ? null : JSON.parse(_) as unknown,
-      catch: this.onError
-    })
-  }
-
-  get unsafeJson(): unknown {
-    return Effect.runSync(this.json)
-  }
-
-  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, E> {
-    return Effect.flatMap(this.text, (_) =>
-      Effect.try({
-        try: () => UrlParams.fromInput(new URLSearchParams(_)),
-        catch: this.onError
-      }))
-  }
-
-  get stream(): Stream.Stream<Uint8Array, E> {
-    return NodeStream.fromReadable<E, Uint8Array>(
-      () => this.source,
-      this.onError
-    )
-  }
-
-  get arrayBuffer(): Effect.Effect<ArrayBuffer, E> {
-    return Effect.flatMap(
-      IncomingMessage.MaxBodySize,
-      (maxBodySize) =>
-        NodeStream.toUint8Array(() => this.source, {
-          onFailure: this.onError,
-          maxBytes: Option.getOrUndefined(maxBodySize)
-        })
-    )
-  }
-}

package/src/internal/httpPlatform.ts

@@ -1,46 +0,0 @@
-import * as EtagImpl from "@effect/platform/Etag"
-import * as Headers from "@effect/platform/Headers"
-import * as Platform from "@effect/platform/HttpPlatform"
-import * as ServerResponse from "@effect/platform/HttpServerResponse"
-import { pipe } from "effect/Function"
-import * as Layer from "effect/Layer"
-import Mime from "mime"
-import * as Fs from "node:fs"
-import { Readable } from "node:stream"
-import * as FileSystem from "../NodeFileSystem.js"
-
-/** @internal */
-export const make = Platform.make({
-  fileResponse(path, status, statusText, headers, start, end, contentLength) {
-    const stream = Fs.createReadStream(path, { start, end })
-    return ServerResponse.raw(stream, {
-      headers: {
-        ...headers,
-        "content-type": headers["content-type"] ?? Mime.getType(path) ?? "application/octet-stream",
-        "content-length": contentLength.toString()
-      },
-      status,
-      statusText
-    })
-  },
-  fileWebResponse(file, status, statusText, headers, _options) {
-    return ServerResponse.raw(Readable.fromWeb(file.stream() as any), {
-      headers: Headers.merge(
-        headers,
-        Headers.unsafeFromRecord({
-          "content-type": headers["content-type"] ?? Mime.getType(file.name) ?? "application/octet-stream",
-          "content-length": file.size.toString()
-        })
-      ),
-      status,
-      statusText
-    })
-  }
-})
-
-/** @internal */
-export const layer = pipe(
-  Layer.effect(Platform.HttpPlatform, make),
-  Layer.provide(FileSystem.layer),
-  Layer.provide(EtagImpl.layer)
-)