Function make

packages/platform-node/src/internal/httpServer.ts:41–119

(
  evaluate: LazyArg<Http.Server>,
  options: Net.ListenOptions
)

/** @internal */
export const make = (
  evaluate: LazyArg<Http.Server>,
  options: Net.ListenOptions
): Effect.Effect<Server.HttpServer, Error.ServeError, Scope.Scope> =>
  Effect.gen(function*() {
    const scope = yield* Effect.scope
    const server = yield* Effect.acquireRelease(
      Effect.sync(evaluate),
      (server) =>
        Effect.async<void>((resume) => {
          if (!server.listening) {
            return resume(Effect.void)
          }
          server.close((error) => {
            if (error) {
              resume(Effect.die(error))
            } else {
              resume(Effect.void)
            }
          })
        })
    )

    yield* Effect.async<void, Error.ServeError>((resume) => {
      function onError(cause: Error) {
        resume(Effect.fail(new Error.ServeError({ cause })))
      }
      server.on("error", onError)
      server.listen(options, () => {
        server.off("error", onError)
        resume(Effect.void)
      })
    })

    const address = server.address()!

    const wss = yield* pipe(
      Effect.acquireRelease(
        Effect.sync(() => new WS.WebSocketServer({ noServer: true })),
        (wss) =>
          Effect.async<void>((resume) => {
            wss.close(() => resume(Effect.void))
          })
      ),
      Scope.extend(scope),
      Effect.cached
    )

    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