@effect/platform-node-shared 0.0.0-snapshot-c0ae728e57df2c572ea803e1bb7121088cd67b49

package/src/internal/http/multipart.ts

@@ -0,0 +1,107 @@
+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<Multipart.Part, Multipart.MultipartError> =>
+  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<Uint8Array, Multipart.MultipartError>
+
+  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

@@ -0,0 +1,58 @@
+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<string, BadArgument> =>
+  Effect.try({
+    try: () => NodeUrl.fileURLToPath(url),
+    catch: (error) =>
+      BadArgument({
+        module: "Path",
+        method: "fromFileUrl",
+        message: `${error}`
+      })
+  })
+
+const toFileUrl = (path: string): Effect.Effect<URL, BadArgument> =>
+  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

@@ -0,0 +1,36 @@
+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<A, E>,
+  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

@@ -0,0 +1,57 @@
+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 "../NodeStream.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

@@ -0,0 +1,325 @@
+import { type PlatformError, SystemError } from "@effect/platform/Error"
+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 { FromReadableOptions, FromWritableOptions } from "../NodeStream.js"
+
+/** @internal */
+export const fromReadable = <E, A = Uint8Array>(
+  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
+  onError: (error: unknown) => E,
+  { chunkSize }: FromReadableOptions = {}
+): Stream.Stream<A, E> =>
+  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<string, E> => {
+  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<Uint8Array, E> => {
+  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<void, IE | E>, 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<A, E, R>) => Stream.Stream<B, E | E2, R>,
+  <R, E, A, E2, B = Uint8Array>(
+    self: Stream.Stream<A, E, R>,
+    duplex: LazyArg<Duplex>,
+    onError: (error: unknown) => E2,
+    options?: FromReadableOptions & FromWritableOptions
+  ) => Stream.Stream<B, E | E2, R>
+>(
+  (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<string | Uint8Array, E, R>) => Stream.Stream<Uint8Array, E | PlatformError, R>,
+  <R, E>(
+    self: Stream.Stream<string | Uint8Array, E, R>,
+    duplex: LazyArg<Duplex>
+  ) => Stream.Stream<Uint8Array, E | PlatformError, R>
+>(
+  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<void, E>, 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<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<void, never, never>((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<void, never, never>((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<void, E>, 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<void, E>, 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

@@ -0,0 +1,123 @@
+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<Terminal.UserInput, Terminal.QuitException, never>((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<string, Terminal.QuitException, never>((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<void, Error.PlatformError> =>
+      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<Terminal.Terminal> = Layer.scoped(
+  Terminal.Terminal,
+  make(defaultShouldQuit)
+)