@effect/platform-node 0.0.0-snapshot-c0ae728e57df2c572ea803e1bb7121088cd67b49

package/src/internal/http/server.ts

@@ -0,0 +1,375 @@
+import * as Etag from "@effect/platform-node-shared/Http/Etag"
+import * as MultipartNode from "@effect/platform-node-shared/Http/Multipart"
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as App from "@effect/platform/Http/App"
+import type * 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 Middleware from "@effect/platform/Http/Middleware"
+import type * as Multipart from "@effect/platform/Http/Multipart"
+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 type * as Path from "@effect/platform/Path"
+import * as Cause from "effect/Cause"
+import * as Config from "effect/Config"
+import * as Effect from "effect/Effect"
+import { type LazyArg } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+import type * as Http from "node:http"
+import type * as Net from "node:net"
+import { Readable } from "node:stream"
+import { pipeline } from "node:stream/promises"
+import * as NodeContext from "../../NodeContext.js"
+import * as NodeSink from "../../NodeSink.js"
+import { IncomingMessageImpl } from "./incomingMessage.js"
+import * as internalPlatform from "./platform.js"
+
+/** @internal */
+export const make = (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+): Effect.Effect<Server.Server, Error.ServeError, Scope.Scope> =>
+  Effect.gen(function*(_) {
+    const server = yield* _(Effect.acquireRelease(
+      Effect.sync(evaluate),
+      (server) =>
+        Effect.async<void, never, never>((resume) => {
+          server.close((error) => {
+            if (error) {
+              resume(Effect.die(error))
+            } else {
+              resume(Effect.unit)
+            }
+          })
+        })
+    ))
+
+    yield* _(Effect.async<void, Error.ServeError, never>((resume) => {
+      server.on("error", (error) => {
+        resume(Effect.fail(Error.ServeError({ error })))
+      })
+      server.listen(options, () => {
+        resume(Effect.unit)
+      })
+    }))
+
+    const address = server.address()!
+
+    return Server.make({
+      address: typeof address === "string" ?
+        {
+          _tag: "UnixAddress",
+          path: address
+        } :
+        {
+          _tag: "TcpAddress",
+          hostname: address.address === "::" ? "0.0.0.0" : address.address,
+          port: address.port
+        },
+      serve: (httpApp, middleware) =>
+        Effect.gen(function*(_) {
+          const handler = yield* _(makeHandler(httpApp, middleware!))
+          yield* _(Effect.addFinalizer(() =>
+            Effect.sync(() => {
+              server.off("request", handler)
+            })
+          ))
+          server.on("request", handler)
+        })
+    })
+  }).pipe(
+    Effect.locally(
+      IncomingMessage.maxBodySize,
+      Option.some(FileSystem.Size(1024 * 1024 * 10))
+    )
+  )
+
+/** @internal */
+export const makeHandler: {
+  <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void,
+    never,
+    Exclude<R, ServerRequest.ServerRequest | Scope.Scope>
+  >
+  <R, E, App extends App.Default<any, any>>(
+    httpApp: App.Default<R, E>,
+    middleware: Middleware.Middleware.Applied<R, E, App>
+  ): Effect.Effect<
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void,
+    never,
+    Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
+  >
+} = <R, E>(httpApp: App.Default<R, E>, middleware?: Middleware.Middleware) => {
+  const handledApp = Effect.scoped(
+    middleware
+      ? middleware(App.withDefaultMiddleware(respond(httpApp)))
+      : App.withDefaultMiddleware(respond(httpApp))
+  )
+  return Effect.map(Effect.runtime<R>(), (runtime) => {
+    const runFork = Runtime.runFork(runtime)
+    return function handler(nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) {
+      const fiber = runFork(
+        Effect.provideService(
+          handledApp,
+          ServerRequest.ServerRequest,
+          new ServerRequestImpl(nodeRequest, nodeResponse)
+        )
+      )
+      nodeResponse.on("close", () => {
+        if (!nodeResponse.writableEnded) {
+          if (!nodeResponse.headersSent) {
+            nodeResponse.writeHead(499)
+          }
+          nodeResponse.end()
+          runFork(fiber.interruptAsFork(Error.clientAbortFiberId))
+        }
+      })
+    }
+  })
+}
+
+const respond = Middleware.make((httpApp) =>
+  Effect.uninterruptibleMask((restore) =>
+    Effect.flatMap(ServerRequest.ServerRequest, (request) =>
+      Effect.tapErrorCause(
+        restore(
+          Effect.tap(
+            Effect.flatMap(
+              httpApp,
+              (response) => Effect.flatMap(App.preResponseHandler, (f) => f(request, response))
+            ),
+            (response) => handleResponse(request, response)
+          )
+        ),
+        (cause) =>
+          Effect.sync(() => {
+            const nodeResponse = (request as ServerRequestImpl).response
+            if (!nodeResponse.headersSent) {
+              nodeResponse.writeHead(Cause.isInterruptedOnly(cause) ? 503 : 500)
+            }
+            if (!nodeResponse.writableEnded) {
+              nodeResponse.end()
+            }
+          })
+      ))
+  )
+)
+
+class ServerRequestImpl extends IncomingMessageImpl<Error.RequestError> implements ServerRequest.ServerRequest {
+  readonly [ServerRequest.TypeId]: ServerRequest.TypeId
+
+  constructor(
+    readonly source: Http.IncomingMessage,
+    readonly response: Http.ServerResponse,
+    readonly url = source.url!,
+    private headersOverride?: Headers.Headers,
+    remoteAddressOverride?: string
+  ) {
+    super(source, (_) =>
+      Error.RequestError({
+        request: this,
+        reason: "Decode",
+        error: _
+      }), remoteAddressOverride)
+    this[ServerRequest.TypeId] = ServerRequest.TypeId
+  }
+
+  modify(
+    options: {
+      readonly url?: string | undefined
+      readonly headers?: Headers.Headers | undefined
+      readonly remoteAddress?: string | undefined
+    }
+  ) {
+    return new ServerRequestImpl(
+      this.source,
+      this.response,
+      options.url ?? this.url,
+      options.headers ?? this.headersOverride,
+      options.remoteAddress ?? this.remoteAddressOverride
+    )
+  }
+
+  get originalUrl(): string {
+    return this.source.url!
+  }
+
+  get method(): Method {
+    return this.source.method!.toUpperCase() as Method
+  }
+
+  get headers(): Headers.Headers {
+    this.headersOverride ??= this.source.headers as Headers.Headers
+    return this.headersOverride
+  }
+
+  private multipartEffect:
+    | Effect.Effect<
+      Multipart.Persisted,
+      Multipart.MultipartError,
+      Scope.Scope | FileSystem.FileSystem | Path.Path
+    >
+    | undefined
+  get multipart(): Effect.Effect<
+    Multipart.Persisted,
+    Multipart.MultipartError,
+    Scope.Scope | FileSystem.FileSystem | Path.Path
+  > {
+    if (this.multipartEffect) {
+      return this.multipartEffect
+    }
+    this.multipartEffect = Effect.runSync(Effect.cached(
+      MultipartNode.persisted(this.source, this.source.headers)
+    ))
+    return this.multipartEffect
+  }
+
+  get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
+    return MultipartNode.stream(this.source, this.source.headers)
+  }
+
+  toString(): string {
+    return `ServerRequest(${this.method} ${this.url})`
+  }
+
+  toJSON(): unknown {
+    return {
+      _tag: "ServerRequest",
+      method: this.method,
+      url: this.url,
+      originalUrl: this.originalUrl,
+      headers: this.headers
+    }
+  }
+}
+
+/** @internal */
+export const layerServer = (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+) => Layer.scoped(Server.Server, make(evaluate, options))
+
+/** @internal */
+export const layer = (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+) =>
+  Layer.mergeAll(
+    Layer.scoped(Server.Server, make(evaluate, options)),
+    internalPlatform.layer,
+    Etag.layerWeak,
+    NodeContext.layer
+  )
+
+/** @internal */
+export const layerConfig = (
+  evaluate: LazyArg<Http.Server>,
+  options: Config.Config.Wrap<Net.ListenOptions>
+) =>
+  Layer.mergeAll(
+    Layer.scoped(
+      Server.Server,
+      Effect.flatMap(Config.unwrap(options), (options) => make(evaluate, options))
+    ),
+    internalPlatform.layer,
+    Etag.layerWeak,
+    NodeContext.layer
+  )
+
+const handleResponse = (request: ServerRequest.ServerRequest, response: ServerResponse.ServerResponse) =>
+  Effect.suspend((): Effect.Effect<void, Error.ResponseError> => {
+    const nodeResponse = (request as ServerRequestImpl).response
+    if (request.method === "HEAD") {
+      nodeResponse.writeHead(response.status, response.headers)
+      nodeResponse.end()
+      return Effect.unit
+    }
+    const body = response.body
+    switch (body._tag) {
+      case "Empty": {
+        nodeResponse.writeHead(response.status, response.headers)
+        nodeResponse.end()
+        return Effect.unit
+      }
+      case "Raw": {
+        nodeResponse.writeHead(response.status, response.headers)
+        if (
+          typeof body.body === "object" && body.body !== null && "pipe" in body.body &&
+          typeof body.body.pipe === "function"
+        ) {
+          return Effect.tryPromise({
+            try: (signal) => pipeline(body.body as any, nodeResponse, { signal, end: true }),
+            catch: (error) =>
+              Error.ResponseError({
+                request,
+                response,
+                reason: "Decode",
+                error
+              })
+          })
+        }
+        nodeResponse.end(body.body)
+        return Effect.unit
+      }
+      case "Uint8Array": {
+        nodeResponse.writeHead(response.status, response.headers)
+        nodeResponse.end(body.body)
+        return Effect.unit
+      }
+      case "FormData": {
+        return Effect.async<void, Error.ResponseError, never>((resume) => {
+          const r = new Response(body.formData)
+          const headers = {
+            ...response.headers,
+            ...Object.fromEntries(r.headers)
+          }
+          nodeResponse.writeHead(response.status, headers)
+          Readable.fromWeb(r.body as any)
+            .pipe(nodeResponse)
+            .on("error", (error) => {
+              resume(Effect.fail(Error.ResponseError({
+                request,
+                response,
+                reason: "Decode",
+                error
+              })))
+            })
+            .once("finish", () => {
+              resume(Effect.unit)
+            })
+        })
+      }
+      case "Stream": {
+        nodeResponse.writeHead(response.status, response.headers)
+        return Stream.run(
+          Stream.mapError(
+            body.stream,
+            (error) =>
+              Error.ResponseError({
+                request,
+                response,
+                reason: "Decode",
+                error
+              })
+          ),
+          NodeSink.fromWritable(() => nodeResponse, (error) =>
+            Error.ResponseError({
+              request,
+              response,
+              reason: "Decode",
+              error
+            }))
+        )
+      }
+    }
+  })
+
+/** @internal */
+export const requestSource = (self: ServerRequest.ServerRequest): Http.IncomingMessage =>
+  (self as ServerRequestImpl).source

package/src/internal/worker.ts

@@ -0,0 +1,74 @@
+import * as Worker from "@effect/platform/Worker"
+import { WorkerError } from "@effect/platform/WorkerError"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import type * as WorkerThreads from "node:worker_threads"
+
+const platformWorkerImpl = Worker.PlatformWorker.of({
+  [Worker.PlatformWorkerTypeId]: Worker.PlatformWorkerTypeId,
+  spawn<I, O>(worker_: unknown) {
+    return Effect.gen(function*(_) {
+      const worker = worker_ as WorkerThreads.Worker
+      yield* _(Effect.addFinalizer(() =>
+        pipe(
+          Effect.async<void, never, never>((resume) => {
+            worker.once("exit", () => {
+              resume(Effect.unit)
+            })
+            worker.postMessage([1])
+          }),
+          Effect.timeout(5000),
+          Effect.orElse(() => Effect.sync(() => worker.terminate()))
+        )
+      ))
+      const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
+      yield* _(Effect.addFinalizer(() => Queue.shutdown(queue)))
+      const fiber = yield* _(
+        Effect.async<never, WorkerError, never>((resume) => {
+          worker.on("message", (message: Worker.BackingWorker.Message<O>) => {
+            queue.unsafeOffer(message)
+          })
+          worker.on("messageerror", (error) => {
+            resume(Effect.fail(WorkerError("decode", error.message, error.stack)))
+          })
+          worker.on("error", (error) => {
+            resume(Effect.fail(WorkerError("unknown", error.message, error.stack)))
+          })
+          worker.on("exit", (code) => {
+            resume(Effect.fail(WorkerError("unknown", new Error(`exited with code ${code}`))))
+          })
+        }),
+        Effect.interruptible,
+        Effect.forkScoped
+      )
+      const send = (message: I, transfers?: ReadonlyArray<unknown>) =>
+        Effect.try({
+          try: () => worker.postMessage([0, message], transfers as any),
+          catch: (error) => WorkerError("send", (error as any).message, (error as any).stack)
+        })
+      return { fiber, queue, send }
+    })
+  }
+})
+
+/** @internal */
+export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerImpl)
+
+/** @internal */
+export const layerManager = Layer.provide(Worker.layerManager, layerWorker)
+
+/** @internal */
+export const makePool = Worker.makePool<WorkerThreads.Worker>()
+
+/** @internal */
+export const makePoolLayer = Worker.makePoolLayer<WorkerThreads.Worker>(layerManager)
+
+/** @internal */
+export const makePoolSerialized = Worker.makePoolSerialized<WorkerThreads.Worker>()
+
+/** @internal */
+export const makePoolSerializedLayer = Worker.makePoolSerializedLayer<WorkerThreads.Worker>(
+  layerManager
+)

package/src/internal/workerRunner.ts

@@ -0,0 +1,74 @@
+import { WorkerError } from "@effect/platform/WorkerError"
+import * as Runner from "@effect/platform/WorkerRunner"
+import type * as Schema from "@effect/schema/Schema"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import * as Schedule from "effect/Schedule"
+import type * as Stream from "effect/Stream"
+import * as WorkerThreads from "node:worker_threads"
+
+const platformRunnerImpl = Runner.PlatformRunner.of({
+  [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
+  start<I, O>(shutdown: Effect.Effect<void>) {
+    return Effect.gen(function*(_) {
+      if (!WorkerThreads.parentPort) {
+        return yield* _(Effect.fail(WorkerError("spawn", "not in worker")))
+      }
+      const port = WorkerThreads.parentPort
+      const queue = yield* _(Queue.unbounded<I>())
+      yield* _(
+        Effect.async<never, WorkerError, never>((resume) => {
+          port.on("message", (message: Runner.BackingRunner.Message<I>) => {
+            if (message[0] === 0) {
+              queue.unsafeOffer(message[1])
+            } else {
+              Effect.runFork(shutdown)
+            }
+          })
+          port.on("messageerror", (error) => {
+            resume(Effect.fail(WorkerError("decode", error.message, error.stack)))
+          })
+          port.on("error", (error) => {
+            resume(Effect.fail(WorkerError("unknown", error.message, error.stack)))
+          })
+        }),
+        Effect.tapErrorCause((cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : Effect.logDebug(cause)),
+        Effect.retry(Schedule.forever),
+        Effect.annotateLogs({
+          package: "@effect/platform-node",
+          module: "WorkerRunner"
+        }),
+        Effect.interruptible,
+        Effect.forkScoped
+      )
+      const send = (message: O, transfers?: ReadonlyArray<unknown>) =>
+        Effect.sync(() => port.postMessage([1, message], transfers as any))
+      // ready
+      port.postMessage([0])
+      return { queue, send }
+    })
+  }
+})
+
+/** @internal */
+export const layerPlatform = Layer.succeed(Runner.PlatformRunner, platformRunnerImpl)
+
+/** @internal */
+export const layer = <I, R, E, O>(
+  process: (request: I) => Stream.Stream<O, E, R>,
+  options?: Runner.Runner.Options<I, E, O>
+): Layer.Layer<never, WorkerError, R> => Layer.provide(Runner.layer(process, options), layerPlatform)
+
+/** @internal */
+export const layerSerialized = <
+  A extends Schema.TaggedRequest.Any,
+  I,
+  R,
+  Handlers extends Runner.SerializedRunner.Handlers<A>
+>(
+  schema: Schema.Schema<A, I, R>,
+  handlers: Handlers
+): Layer.Layer<never, WorkerError, R | Runner.SerializedRunner.HandlersContext<Handlers>> =>
+  Layer.provide(Runner.layerSerialized(schema, handlers), layerPlatform)