@effect/platform-node 0.42.10 → 0.43.0

package/src/internal/http/multipart.ts

@@ -1,107 +0,0 @@
-import * as Multipart from "@effect/platform/Http/Multipart"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Stream from "effect/Stream"
-import type { MultipartError, PartInfo } from "multipasta"
-import { decodeField } from "multipasta"
-import * as MP from "multipasta/node"
-import * as NFS from "node:fs"
-import type { IncomingHttpHeaders } from "node:http"
-import type { Readable } from "node:stream"
-import * as NodeStreamP from "node:stream/promises"
-import * as NodeStream from "../stream.js"
-
-/** @internal */
-export const stream = (
-  source: Readable,
-  headers: IncomingHttpHeaders
-): Stream.Stream<never, Multipart.MultipartError, Multipart.Part> =>
-  pipe(
-    Multipart.makeConfig(headers as any),
-    Effect.map(
-      (config) =>
-        NodeStream.fromReadable<Multipart.MultipartError, MP.Part>(() => {
-          const parser = MP.make(config)
-          source.pipe(parser)
-          return parser
-        }, (error) => convertError(error as any))
-    ),
-    Stream.unwrap,
-    Stream.map(convertPart)
-  )
-
-/** @internal */
-export const persisted = (
-  source: Readable,
-  headers: IncomingHttpHeaders
-) =>
-  Multipart.toPersisted(stream(source, headers), (path, file) =>
-    Effect.tryPromise({
-      try: (signal) => NodeStreamP.pipeline((file as FileImpl).file, NFS.createWriteStream(path), { signal }),
-      catch: (error) => Multipart.MultipartError("InternalError", error)
-    }))
-
-const convertPart = (part: MP.Part): Multipart.Part =>
-  part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part)
-
-class FieldImpl implements Multipart.Field {
-  readonly [Multipart.TypeId]: Multipart.TypeId
-  readonly _tag = "Field"
-  readonly key: string
-  readonly contentType: string
-  readonly value: string
-
-  constructor(
-    info: PartInfo,
-    value: Uint8Array
-  ) {
-    this[Multipart.TypeId] = Multipart.TypeId
-    this.key = info.name
-    this.contentType = info.contentType
-    this.value = decodeField(info, value)
-  }
-}
-
-class FileImpl implements Multipart.File {
-  readonly _tag = "File"
-  readonly [Multipart.TypeId]: Multipart.TypeId
-  readonly key: string
-  readonly name: string
-  readonly contentType: string
-  readonly content: Stream.Stream<never, Multipart.MultipartError, Uint8Array>
-
-  constructor(readonly file: MP.FileStream) {
-    this[Multipart.TypeId] = Multipart.TypeId
-    this.key = file.info.name
-    this.name = file.filename ?? file.info.name
-    this.contentType = file.info.contentType
-    this.content = NodeStream.fromReadable(() => file, (error) => Multipart.MultipartError("InternalError", error))
-  }
-}
-
-/** @internal */
-export const fileToReadable = (file: Multipart.File): Readable => (file as FileImpl).file
-
-function convertError(error: MultipartError): Multipart.MultipartError {
-  switch (error._tag) {
-    case "ReachedLimit": {
-      switch (error.limit) {
-        case "MaxParts": {
-          return Multipart.MultipartError("TooManyParts", error)
-        }
-        case "MaxFieldSize": {
-          return Multipart.MultipartError("FieldTooLarge", error)
-        }
-        case "MaxPartSize": {
-          return Multipart.MultipartError("FileTooLarge", error)
-        }
-        case "MaxTotalSize": {
-          return Multipart.MultipartError("BodyTooLarge", error)
-        }
-      }
-    }
-    default: {
-      return Multipart.MultipartError("Parse", error)
-    }
-  }
-}

package/src/internal/path.ts

@@ -1,58 +0,0 @@
-import { BadArgument } from "@effect/platform/Error"
-import { Path } from "@effect/platform/Path"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as NodePath from "node:path"
-import * as NodeUrl from "node:url"
-
-const fromFileUrl = (url: URL): Effect.Effect<never, BadArgument, string> =>
-  Effect.try({
-    try: () => NodeUrl.fileURLToPath(url),
-    catch: (error) =>
-      BadArgument({
-        module: "Path",
-        method: "fromFileUrl",
-        message: `${error}`
-      })
-  })
-
-const toFileUrl = (path: string): Effect.Effect<never, BadArgument, URL> =>
-  Effect.try({
-    try: () => NodeUrl.pathToFileURL(path),
-    catch: (error) =>
-      BadArgument({
-        module: "Path",
-        method: "toFileUrl",
-        message: `${error}`
-      })
-  })
-
-/** @internal */
-export const layerPosix = Layer.succeed(
-  Path,
-  Path.of({
-    ...NodePath.posix,
-    fromFileUrl,
-    toFileUrl
-  })
-)
-
-/** @internal */
-export const layerWin32 = Layer.succeed(
-  Path,
-  Path.of({
-    ...NodePath.win32,
-    fromFileUrl,
-    toFileUrl
-  })
-)
-
-/** @internal */
-export const layer = Layer.succeed(
-  Path,
-  Path.of({
-    ...NodePath,
-    fromFileUrl,
-    toFileUrl
-  })
-)

package/src/internal/runtime.ts

@@ -1,36 +0,0 @@
-import { defaultTeardown, type RunMain } from "@effect/platform/Runtime"
-import * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-
-/** @internal */
-export const runMain: RunMain = <E, A>(
-  effect: Effect.Effect<never, E, A>,
-  teardown = defaultTeardown
-) => {
-  const keepAlive = setInterval(() => {}, 2 ** 31 - 1)
-
-  const fiber = Effect.runFork(
-    Effect.tapErrorCause(effect, (cause) => {
-      if (Cause.isInterruptedOnly(cause)) {
-        return Effect.unit
-      }
-      return Effect.logError(cause)
-    })
-  )
-
-  fiber.addObserver((exit) => {
-    clearInterval(keepAlive)
-    teardown(exit, (code) => {
-      process.exit(code)
-    })
-  })
-
-  function onSigint() {
-    process.removeListener("SIGINT", onSigint)
-    process.removeListener("SIGTERM", onSigint)
-    fiber.unsafeInterruptAsFork(fiber.id())
-  }
-
-  process.once("SIGINT", onSigint)
-  process.once("SIGTERM", onSigint)
-}

package/src/internal/sink.ts

@@ -1,57 +0,0 @@
-import * as Channel from "effect/Channel"
-import type * as Chunk from "effect/Chunk"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import type { LazyArg } from "effect/Function"
-import * as Sink from "effect/Sink"
-import type { Writable } from "node:stream"
-import type { FromWritableOptions } from "../Stream.js"
-import { writeInput } from "./stream.js"
-
-/** @internal */
-export const fromWritable = <E, A = Uint8Array | string>(
-  evaluate: LazyArg<Writable | NodeJS.WritableStream>,
-  onError: (error: unknown) => E,
-  options?: FromWritableOptions
-): Sink.Sink<never, E, A, never, void> => Sink.fromChannel(fromWritableChannel(evaluate, onError, options))
-
-/** @internal */
-export const fromWritableChannel = <IE, OE, A>(
-  writable: LazyArg<Writable | NodeJS.WritableStream>,
-  onError: (error: unknown) => OE,
-  options?: FromWritableOptions
-): Channel.Channel<never, IE, Chunk.Chunk<A>, unknown, IE | OE, Chunk.Chunk<never>, void> =>
-  Channel.flatMap(
-    Effect.zip(
-      Effect.sync(() => writable()),
-      Deferred.make<IE | OE, void>()
-    ),
-    ([writable, deferred]) =>
-      Channel.embedInput(
-        writableOutput(writable, deferred, onError),
-        writeInput<IE, A>(
-          writable,
-          (cause) => Deferred.failCause(deferred, cause),
-          options,
-          Deferred.complete(deferred, Effect.unit)
-        )
-      )
-  )
-
-const writableOutput = <IE, E>(
-  writable: Writable | NodeJS.WritableStream,
-  deferred: Deferred.Deferred<IE | E, void>,
-  onError: (error: unknown) => E
-) =>
-  Effect.suspend(() => {
-    function handleError(err: unknown) {
-      Deferred.unsafeDone(deferred, Effect.fail(onError(err)))
-    }
-    writable.on("error", handleError)
-    return Effect.ensuring(
-      Deferred.await(deferred),
-      Effect.sync(() => {
-        writable.removeListener("error", handleError)
-      })
-    )
-  })

package/src/internal/stream.ts

@@ -1,325 +0,0 @@
-import type { SizeInput } from "@effect/platform/FileSystem"
-import type * as Cause from "effect/Cause"
-import * as Channel from "effect/Channel"
-import * as Chunk from "effect/Chunk"
-import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Exit from "effect/Exit"
-import type { LazyArg } from "effect/Function"
-import { dual } from "effect/Function"
-import * as Queue from "effect/Queue"
-import type * as AsyncInput from "effect/SingleProducerAsyncInput"
-import * as Stream from "effect/Stream"
-import type { Duplex, Readable, Writable } from "node:stream"
-import { type PlatformError, SystemError } from "../Error.js"
-import type { FromReadableOptions, FromWritableOptions } from "../Stream.js"
-
-/** @internal */
-export const fromReadable = <E, A = Uint8Array>(
-  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
-  onError: (error: unknown) => E,
-  { chunkSize }: FromReadableOptions = {}
-): Stream.Stream<never, E, A> =>
-  Stream.fromChannel(
-    fromReadableChannel<E, A>(evaluate, onError, chunkSize ? Number(chunkSize) : undefined)
-  )
-
-/** @internal */
-export const toString = <E>(
-  readable: LazyArg<Readable | NodeJS.ReadableStream>,
-  options: {
-    readonly onFailure: (error: unknown) => E
-    readonly encoding?: BufferEncoding | undefined
-    readonly maxBytes?: SizeInput | undefined
-  }
-): Effect.Effect<never, E, string> => {
-  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const stream = readable()
-      stream.setEncoding(options.encoding ?? "utf8")
-      return stream
-    }),
-    (stream) =>
-      Effect.async((resume) => {
-        let string = ""
-        let bytes = 0
-        stream.once("error", (err) => {
-          resume(Effect.fail(options.onFailure(err)))
-        })
-        stream.once("end", () => {
-          resume(Effect.succeed(string))
-        })
-        stream.on("data", (chunk) => {
-          string += chunk
-          bytes += Buffer.byteLength(chunk)
-          if (maxBytesNumber && bytes > maxBytesNumber) {
-            resume(Effect.fail(options.onFailure(new Error("maxBytes exceeded"))))
-          }
-        })
-      }),
-    (stream) =>
-      Effect.sync(() => {
-        stream.removeAllListeners()
-        if ("closed" in stream && !stream.closed) {
-          stream.destroy()
-        }
-      })
-  )
-}
-
-/** @internal */
-export const toUint8Array = <E>(
-  readable: LazyArg<Readable | NodeJS.ReadableStream>,
-  options: {
-    readonly onFailure: (error: unknown) => E
-    readonly maxBytes?: SizeInput | undefined
-  }
-): Effect.Effect<never, E, Uint8Array> => {
-  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined
-  return Effect.acquireUseRelease(
-    Effect.sync(readable),
-    (stream) =>
-      Effect.async((resume) => {
-        let buffer = Buffer.alloc(0)
-        let bytes = 0
-        stream.once("error", (err) => {
-          resume(Effect.fail(options.onFailure(err)))
-        })
-        stream.once("end", () => {
-          resume(Effect.succeed(buffer))
-        })
-        stream.on("data", (chunk) => {
-          buffer = Buffer.concat([buffer, chunk])
-          bytes += chunk.length
-          if (maxBytesNumber && bytes > maxBytesNumber) {
-            resume(Effect.fail(options.onFailure(new Error("maxBytes exceeded"))))
-          }
-        })
-      }),
-    (stream) =>
-      Effect.sync(() => {
-        stream.removeAllListeners()
-        if ("closed" in stream && !stream.closed) {
-          stream.destroy()
-        }
-      })
-  )
-}
-
-/** @internal */
-export const fromDuplex = <IE, E, I = Uint8Array | string, O = Uint8Array>(
-  evaluate: LazyArg<Duplex>,
-  onError: (error: unknown) => E,
-  options: FromReadableOptions & FromWritableOptions = {}
-): Channel.Channel<never, IE, Chunk.Chunk<I>, unknown, IE | E, Chunk.Chunk<O>, void> =>
-  Channel.acquireUseRelease(
-    Effect.tap(
-      Effect.zip(
-        Effect.sync(evaluate),
-        Queue.unbounded<Either.Either<Exit.Exit<IE | E, void>, void>>()
-      ),
-      ([duplex, queue]) => readableOffer(duplex, queue, onError)
-    ),
-    ([duplex, queue]) =>
-      Channel.embedInput(
-        readableTake(duplex, queue, options.chunkSize ? Number(options.chunkSize) : undefined),
-        writeInput(
-          duplex,
-          (cause) => Queue.offer(queue, Either.left(Exit.failCause(cause))),
-          options
-        )
-      ),
-    ([duplex, queue]) =>
-      Effect.zipRight(
-        Effect.sync(() => {
-          duplex.removeAllListeners()
-          if (!duplex.closed) {
-            duplex.destroy()
-          }
-        }),
-        Queue.shutdown(queue)
-      )
-  )
-
-/** @internal */
-export const pipeThroughDuplex = dual<
-  <E2, B = Uint8Array>(
-    duplex: LazyArg<Duplex>,
-    onError: (error: unknown) => E2,
-    options?: FromReadableOptions & FromWritableOptions
-  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E | E2, B>,
-  <R, E, A, E2, B = Uint8Array>(
-    self: Stream.Stream<R, E, A>,
-    duplex: LazyArg<Duplex>,
-    onError: (error: unknown) => E2,
-    options?: FromReadableOptions & FromWritableOptions
-  ) => Stream.Stream<R, E | E2, B>
->(
-  (args) => Stream.StreamTypeId in args[0],
-  (self, duplex, onError, options) =>
-    Stream.pipeThroughChannelOrFail(
-      self,
-      fromDuplex(duplex, onError, options)
-    )
-)
-
-/** @internal */
-export const pipeThroughSimple = dual<
-  (
-    duplex: LazyArg<Duplex>
-  ) => <R, E>(self: Stream.Stream<R, E, string | Uint8Array>) => Stream.Stream<R, E | PlatformError, Uint8Array>,
-  <R, E>(
-    self: Stream.Stream<R, E, string | Uint8Array>,
-    duplex: LazyArg<Duplex>
-  ) => Stream.Stream<R, E | PlatformError, Uint8Array>
->(
-  2,
-  (self, duplex) =>
-    Stream.pipeThroughChannelOrFail(
-      self,
-      fromDuplex(duplex, (error) =>
-        SystemError({
-          module: "Stream",
-          method: "pipeThroughSimple",
-          pathOrDescriptor: "",
-          reason: "Unknown",
-          message: String(error)
-        }))
-    )
-)
-
-/** @internal */
-export const fromReadableChannel = <E, A = Uint8Array>(
-  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
-  onError: (error: unknown) => E,
-  chunkSize: number | undefined
-): Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> =>
-  Channel.acquireUseRelease(
-    Effect.tap(
-      Effect.zip(
-        Effect.sync(evaluate),
-        Queue.unbounded<Either.Either<Exit.Exit<E, void>, void>>()
-      ),
-      ([readable, queue]) => readableOffer(readable, queue, onError)
-    ),
-    ([readable, queue]) => readableTake(readable, queue, chunkSize),
-    ([readable, queue]) =>
-      Effect.zipRight(
-        Effect.sync(() => {
-          readable.removeAllListeners()
-          if ("closed" in readable && !readable.closed) {
-            readable.destroy()
-          }
-        }),
-        Queue.shutdown(queue)
-      )
-  )
-
-/** @internal */
-export const writeInput = <IE, A>(
-  writable: Writable | NodeJS.WritableStream,
-  onFailure: (cause: Cause.Cause<IE>) => Effect.Effect<never, never, void>,
-  { encoding, endOnDone = true }: FromWritableOptions = {},
-  onDone = Effect.unit
-): AsyncInput.AsyncInputProducer<IE, Chunk.Chunk<A>, unknown> => {
-  const write = writeEffect(writable, encoding)
-  const close = endOnDone
-    ? Effect.async<never, never, void>((resume) => {
-      if ("closed" in writable && writable.closed) {
-        resume(Effect.unit)
-      } else {
-        writable.once("finish", () => resume(Effect.unit))
-        writable.end()
-      }
-    })
-    : Effect.unit
-  return {
-    awaitRead: () => Effect.unit,
-    emit: write,
-    error: (cause) => Effect.zipRight(close, onFailure(cause)),
-    done: (_) => Effect.zipRight(close, onDone)
-  }
-}
-
-/** @internal */
-export const writeEffect = <A>(
-  writable: Writable | NodeJS.WritableStream,
-  encoding?: BufferEncoding
-) =>
-(chunk: Chunk.Chunk<A>) =>
-  chunk.length === 0 ?
-    Effect.unit :
-    Effect.async<never, never, void>((resume) => {
-      const iterator = chunk[Symbol.iterator]()
-      let next = iterator.next()
-      function loop() {
-        const item = next
-        next = iterator.next()
-        const success = writable.write(item.value, encoding as any)
-        if (next.done) {
-          resume(Effect.unit)
-        } else if (success) {
-          loop()
-        } else {
-          writable.once("drain", loop)
-        }
-      }
-      loop()
-    })
-
-const readableOffer = <E>(
-  readable: Readable | NodeJS.ReadableStream,
-  queue: Queue.Queue<Either.Either<Exit.Exit<E, void>, void>>,
-  onError: (error: unknown) => E
-) =>
-  Effect.sync(() => {
-    readable.on("readable", () => {
-      const size = queue.unsafeSize()
-      if (size._tag === "Some" && size.value <= 0) {
-        queue.unsafeOffer(Either.right(void 0))
-      }
-    })
-    readable.on("error", (err) => {
-      queue.unsafeOffer(Either.left(Exit.fail(onError(err))))
-    })
-    readable.on("end", () => {
-      queue.unsafeOffer(Either.left(Exit.unit))
-    })
-    if (readable.readable) {
-      queue.unsafeOffer(Either.right(void 0))
-    }
-  })
-
-const readableTake = <E, A>(
-  readable: Readable | NodeJS.ReadableStream,
-  queue: Queue.Queue<Either.Either<Exit.Exit<E, void>, void>>,
-  chunkSize: number | undefined
-) => {
-  const read = readChunkChannel<A>(readable, chunkSize)
-  const loop: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = Channel.flatMap(
-    Queue.take(queue),
-    Either.match({
-      onLeft: Exit.match({
-        onFailure: Channel.failCause,
-        onSuccess: (_) => Channel.unit
-      }),
-      onRight: (_) => Channel.flatMap(read, () => loop)
-    })
-  )
-  return loop
-}
-
-const readChunkChannel = <A>(
-  readable: Readable | NodeJS.ReadableStream,
-  chunkSize: number | undefined
-) =>
-  Channel.suspend(() => {
-    const arr: Array<A> = []
-    let chunk = readable.read(chunkSize)
-    while (chunk !== null) {
-      arr.push(chunk)
-      chunk = readable.read(chunkSize)
-    }
-    return Channel.write(Chunk.unsafeFromArray(arr))
-  })

package/src/internal/terminal.ts

@@ -1,123 +0,0 @@
-import * as Error from "@effect/platform/Error"
-import * as Terminal from "@effect/platform/Terminal"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as readline from "node:readline"
-
-const defaultShouldQuit = (input: Terminal.UserInput): boolean =>
-  input.key.ctrl && (input.key.name === "c" || input.key.name === "d")
-
-/** @internal */
-export const make = (
-  shouldQuit: (input: Terminal.UserInput) => boolean = defaultShouldQuit
-) =>
-  Effect.gen(function*(_) {
-    const input = yield* _(Effect.sync(() => globalThis.process.stdin))
-    const output = yield* _(Effect.sync(() => globalThis.process.stdout))
-
-    // Acquire a readline interface
-    const acquireReadlineInterface = Effect.sync(() =>
-      readline.createInterface({
-        input,
-        escapeCodeTimeout: 50
-      })
-    )
-
-    // Uses the readline interface to force `stdin` to emit keypress events
-    const emitKeypressEvents = (rl: readline.Interface): readline.Interface => {
-      readline.emitKeypressEvents(input, rl)
-      if (input.isTTY) {
-        input.setRawMode(true)
-      }
-      return rl
-    }
-
-    // Close the `readline` interface
-    const releaseReadlineInterface = (rl: readline.Interface) =>
-      Effect.sync(() => {
-        if (input.isTTY) {
-          input.setRawMode(false)
-        }
-        rl.close()
-      })
-
-    // Handle the `"keypress"` event emitted by `stdin` (forced by readline)
-    const handleKeypressEvent = (input: typeof globalThis.process.stdin) =>
-      Effect.async<never, Terminal.QuitException, Terminal.UserInput>((resume) => {
-        const handleKeypress = (input: string | undefined, key: readline.Key) => {
-          const userInput: Terminal.UserInput = {
-            input: Option.fromNullable(input),
-            key: {
-              name: key.name || "",
-              ctrl: key.ctrl || false,
-              meta: key.meta || false,
-              shift: key.shift || false
-            }
-          }
-          if (shouldQuit(userInput)) {
-            resume(Effect.fail(new Terminal.QuitException()))
-          } else {
-            resume(Effect.succeed(userInput))
-          }
-        }
-        input.once("keypress", handleKeypress)
-        return Effect.sync(() => {
-          input.removeListener("keypress", handleKeypress)
-        })
-      })
-
-    // Handle the `"line"` event emitted by the readline interface
-    const handleLineEvent = (rl: readline.Interface) =>
-      Effect.async<never, Terminal.QuitException, string>((resume) => {
-        const handleLine = (line: string) => {
-          resume(Effect.succeed(line))
-        }
-        rl.on("line", handleLine)
-        return Effect.sync(() => {
-          rl.removeListener("line", handleLine)
-        })
-      })
-
-    const readInput = Effect.acquireUseRelease(
-      acquireReadlineInterface.pipe(Effect.map(emitKeypressEvents)),
-      () => handleKeypressEvent(input),
-      releaseReadlineInterface
-    )
-
-    const readLine = Effect.acquireUseRelease(
-      acquireReadlineInterface,
-      (rl) => handleLineEvent(rl),
-      releaseReadlineInterface
-    )
-
-    const display = (prompt: string): Effect.Effect<never, Error.PlatformError, void> =>
-      Effect.uninterruptible(
-        Effect.async((resume) => {
-          output.write(prompt, (err) => {
-            if (err) {
-              resume(Effect.fail(Error.BadArgument({
-                module: "Terminal",
-                method: "display",
-                message: (err as Error).message ?? String(err)
-              })))
-            }
-            resume(Effect.unit)
-          })
-        })
-      )
-
-    return Terminal.Terminal.of({
-      // The columns property can be undefined if stdout was redirected
-      columns: Effect.sync(() => output.columns || 0),
-      readInput,
-      readLine,
-      display
-    })
-  })
-
-/** @internal */
-export const layer: Layer.Layer<never, never, Terminal.Terminal> = Layer.scoped(
-  Terminal.Terminal,
-  make(defaultShouldQuit)
-)