@effect/platform-node-shared 0.57.0 → 4.0.0-beta.0

package/src/internal/multipart.ts

@@ -1,141 +0,0 @@
-import * as Multipart from "@effect/platform/Multipart"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Inspectable from "effect/Inspectable"
-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: (cause) => new Multipart.MultipartError({ reason: "InternalError", cause })
-    }))
-
-const convertPart = (part: MP.Part): Multipart.Part =>
-  part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part)
-
-abstract class PartBase extends Inspectable.Class {
-  readonly [Multipart.TypeId]: Multipart.TypeId
-  constructor() {
-    super()
-    this[Multipart.TypeId] = Multipart.TypeId
-  }
-}
-
-class FieldImpl extends PartBase implements Multipart.Field {
-  readonly _tag = "Field"
-  readonly key: string
-  readonly contentType: string
-  readonly value: string
-
-  constructor(
-    info: PartInfo,
-    value: Uint8Array
-  ) {
-    super()
-    this.key = info.name
-    this.contentType = info.contentType
-    this.value = decodeField(info, value)
-  }
-
-  toJSON(): unknown {
-    return {
-      _id: "@effect/platform/Multipart/Part",
-      _tag: "Field",
-      key: this.key,
-      value: this.value,
-      contentType: this.contentType
-    }
-  }
-}
-
-class FileImpl extends PartBase implements Multipart.File {
-  readonly _tag = "File"
-  readonly key: string
-  readonly name: string
-  readonly contentType: string
-  readonly content: Stream.Stream<Uint8Array, Multipart.MultipartError>
-  readonly contentEffect: Effect.Effect<Uint8Array, Multipart.MultipartError>
-
-  constructor(readonly file: MP.FileStream) {
-    super()
-    this.key = file.info.name
-    this.name = file.filename ?? file.info.name
-    this.contentType = file.info.contentType
-    this.content = NodeStream.fromReadable(
-      () => file,
-      (cause) => new Multipart.MultipartError({ reason: "InternalError", cause })
-    )
-    this.contentEffect = NodeStream.toUint8Array(() => file, {
-      onFailure: (cause) => new Multipart.MultipartError({ reason: "InternalError", cause })
-    })
-  }
-
-  toJSON(): unknown {
-    return {
-      _id: "@effect/platform/Multipart/Part",
-      _tag: "File",
-      key: this.key,
-      name: this.name,
-      contentType: this.contentType
-    }
-  }
-}
-
-/** @internal */
-export const fileToReadable = (file: Multipart.File): Readable => (file as FileImpl).file
-
-function convertError(cause: MultipartError): Multipart.MultipartError {
-  switch (cause._tag) {
-    case "ReachedLimit": {
-      switch (cause.limit) {
-        case "MaxParts": {
-          return new Multipart.MultipartError({ reason: "TooManyParts", cause })
-        }
-        case "MaxFieldSize": {
-          return new Multipart.MultipartError({ reason: "FieldTooLarge", cause })
-        }
-        case "MaxPartSize": {
-          return new Multipart.MultipartError({ reason: "FileTooLarge", cause })
-        }
-        case "MaxTotalSize": {
-          return new Multipart.MultipartError({ reason: "BodyTooLarge", cause })
-        }
-      }
-    }
-    default: {
-      return new Multipart.MultipartError({ reason: "Parse", cause })
-    }
-  }
-}

package/src/internal/path.ts

@@ -1,63 +0,0 @@
-import { BadArgument } from "@effect/platform/Error"
-import { Path, TypeId } 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) =>
-      new BadArgument({
-        module: "Path",
-        method: "fromFileUrl",
-        description: `Invalid file URL: ${url}`,
-        cause: error
-      })
-  })
-
-const toFileUrl = (path: string): Effect.Effect<URL, BadArgument> =>
-  Effect.try({
-    try: () => NodeUrl.pathToFileURL(path),
-    catch: (error) =>
-      new BadArgument({
-        module: "Path",
-        method: "toFileUrl",
-        description: `Invalid path: ${path}`,
-        cause: error
-      })
-  })
-
-/** @internal */
-export const layerPosix = Layer.succeed(
-  Path,
-  Path.of({
-    [TypeId]: TypeId,
-    ...NodePath.posix,
-    fromFileUrl,
-    toFileUrl
-  })
-)
-
-/** @internal */
-export const layerWin32 = Layer.succeed(
-  Path,
-  Path.of({
-    [TypeId]: TypeId,
-    ...NodePath.win32,
-    fromFileUrl,
-    toFileUrl
-  })
-)
-
-/** @internal */
-export const layer = Layer.succeed(
-  Path,
-  Path.of({
-    [TypeId]: TypeId,
-    ...NodePath,
-    fromFileUrl,
-    toFileUrl
-  })
-)

package/src/internal/runtime.ts

@@ -1,34 +0,0 @@
-import { makeRunMain } from "@effect/platform/Runtime"
-import { constVoid } from "effect/Function"
-
-/** @internal */
-export const runMain = makeRunMain(({
-  fiber,
-  teardown
-}) => {
-  const keepAlive = setInterval(constVoid, 2 ** 31 - 1)
-  let receivedSignal = false
-
-  fiber.addObserver((exit) => {
-    if (!receivedSignal) {
-      process.removeListener("SIGINT", onSigint)
-      process.removeListener("SIGTERM", onSigint)
-    }
-    clearInterval(keepAlive)
-    teardown(exit, (code) => {
-      if (receivedSignal || code !== 0) {
-        process.exit(code)
-      }
-    })
-  })
-
-  function onSigint() {
-    receivedSignal = true
-    process.removeListener("SIGINT", onSigint)
-    process.removeListener("SIGTERM", onSigint)
-    fiber.unsafeInterruptAsFork(fiber.id())
-  }
-
-  process.on("SIGINT", onSigint)
-  process.on("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 "../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<void, A, never, E> => 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<Chunk.Chunk<never>, Chunk.Chunk<A>, IE | OE, IE, void, unknown> =>
-  Channel.flatMap(
-    Effect.zip(
-      Effect.sync(() => writable()),
-      Deferred.make<void, IE | OE>()
-    ),
-    ([writable, deferred]) =>
-      Channel.embedInput(
-        writableOutput(writable, deferred, onError),
-        writeInput<IE, A>(
-          writable,
-          (cause) => Deferred.failCause(deferred, cause),
-          options,
-          Deferred.complete(deferred, Effect.void)
-        )
-      )
-  )
-
-const writableOutput = <IE, E>(
-  writable: Writable | NodeJS.WritableStream,
-  deferred: Deferred.Deferred<void, IE | E>,
-  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,375 +0,0 @@
-import { type PlatformError, SystemError } from "@effect/platform/Error"
-import type { SizeInput } from "@effect/platform/FileSystem"
-import * 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 Exit from "effect/Exit"
-import * as Fiber from "effect/Fiber"
-import type { LazyArg } from "effect/Function"
-import { dual } from "effect/Function"
-import * as MutableRef from "effect/MutableRef"
-import * as Runtime from "effect/Runtime"
-import type * as AsyncInput from "effect/SingleProducerAsyncInput"
-import * as Stream from "effect/Stream"
-import type { Duplex, Writable } from "node:stream"
-import { Readable } 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,
-  options?: FromReadableOptions
-): Stream.Stream<A, E> =>
-  Stream.fromChannel(
-    fromReadableChannel<E, A>(evaluate, onError, options)
-  )
-
-/** @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(() => {
-        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(() => {
-        if ("closed" in stream && !stream.closed) {
-          stream.destroy()
-        }
-      })
-  )
-}
-
-/** @internal */
-export const fromDuplex = <IE, E, I = string | Uint8Array<ArrayBufferLike>, O = Uint8Array<ArrayBufferLike>>(
-  evaluate: LazyArg<Duplex>,
-  onError: (error: unknown) => E,
-  options?: FromReadableOptions & FromWritableOptions
-): Channel.Channel<
-  Chunk.Chunk<O>,
-  Chunk.Chunk<I>,
-  IE | E,
-  IE
-> =>
-  Channel.suspend(() => {
-    const duplex = evaluate()
-    if (!duplex.readable) {
-      return Channel.void
-    }
-    const exit = MutableRef.make<Exit.Exit<void, IE | E> | undefined>(undefined)
-    return Channel.embedInput(
-      unsafeReadableRead<O, IE | E>(duplex, onError, exit, options),
-      writeInput<IE, I>(
-        duplex,
-        (cause) => Effect.sync(() => MutableRef.set(exit, Exit.failCause(cause))),
-        options
-      )
-    )
-  })
-
-/** @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, (cause) =>
-        new SystemError({
-          module: "Stream",
-          method: "pipeThroughSimple",
-          reason: "Unknown",
-          cause
-        }))
-    )
-)
-
-/** @internal */
-export const fromReadableChannel = <E, A = Uint8Array>(
-  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
-  onError: (error: unknown) => E,
-  options?: FromReadableOptions | undefined
-): Channel.Channel<
-  Chunk.Chunk<A>,
-  unknown,
-  E
-> =>
-  Channel.suspend(() =>
-    unsafeReadableRead(
-      evaluate(),
-      onError,
-      MutableRef.make(undefined),
-      options
-    )
-  )
-
-/** @internal */
-export const writeInput = <IE, A>(
-  writable: Writable | NodeJS.WritableStream,
-  onFailure: (cause: Cause.Cause<IE>) => Effect.Effect<void>,
-  { encoding, endOnDone = true }: FromWritableOptions = {},
-  onDone = Effect.void
-): AsyncInput.AsyncInputProducer<IE, Chunk.Chunk<A>, unknown> => {
-  const write = writeEffect(writable, encoding)
-  const close = endOnDone
-    ? Effect.async<void>((resume) => {
-      if ("closed" in writable && writable.closed) {
-        resume(Effect.void)
-      } else {
-        writable.once("finish", () => resume(Effect.void))
-        writable.end()
-      }
-    })
-    : Effect.void
-  return {
-    awaitRead: () => Effect.void,
-    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.void :
-    Effect.async<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.void)
-        } else if (success) {
-          loop()
-        } else {
-          writable.once("drain", loop)
-        }
-      }
-      loop()
-    })
-
-const unsafeReadableRead = <A, E>(
-  readable: Readable | NodeJS.ReadableStream,
-  onError: (error: unknown) => E,
-  exit: MutableRef.MutableRef<Exit.Exit<void, E> | undefined>,
-  options: FromReadableOptions | undefined
-) => {
-  if (!readable.readable) {
-    return Channel.void
-  }
-
-  const latch = Effect.unsafeMakeLatch(false)
-  function onReadable() {
-    latch.unsafeOpen()
-  }
-  function onErr(err: unknown) {
-    exit.current = Exit.fail(onError(err))
-    latch.unsafeOpen()
-  }
-  function onEnd() {
-    exit.current = Exit.void
-    latch.unsafeOpen()
-  }
-  readable.on("readable", onReadable)
-  readable.on("error", onErr)
-  readable.on("end", onEnd)
-
-  const chunkSize = options?.chunkSize ? Number(options.chunkSize) : undefined
-  const read = Channel.suspend(function loop(): Channel.Channel<Chunk.Chunk<A>, unknown, E> {
-    let item = readable.read(chunkSize) as A | null
-    if (item === null) {
-      if (exit.current) {
-        return Channel.fromEffect(exit.current)
-      }
-      latch.unsafeClose()
-      return Channel.flatMap(latch.await, loop)
-    }
-    const arr = [item as A]
-    while (true) {
-      item = readable.read(chunkSize)
-      if (item === null) {
-        return Channel.flatMap(Channel.write(Chunk.unsafeFromArray(arr)), loop)
-      }
-      arr.push(item as A)
-    }
-  })
-
-  return Channel.ensuring(
-    read,
-    Effect.sync(() => {
-      readable.off("readable", onReadable)
-      readable.off("error", onErr)
-      readable.off("end", onEnd)
-      if (options?.closeOnDone !== false && "closed" in readable && !readable.closed) {
-        readable.destroy()
-      }
-    })
-  )
-}
-
-class StreamAdapter<E, R> extends Readable {
-  readonly readLatch: Effect.Latch
-  fiber: Fiber.RuntimeFiber<void, E> | undefined = undefined
-
-  constructor(
-    runtime: Runtime.Runtime<R>,
-    stream: Stream.Stream<Uint8Array | string, E, R>
-  ) {
-    super({})
-    this.readLatch = Effect.unsafeMakeLatch(false)
-    this.fiber = Runtime.runFork(runtime)(
-      this.readLatch.whenOpen(
-        Stream.runForEachChunk(stream, (chunk) =>
-          this.readLatch.whenOpen(Effect.sync(() => {
-            if (chunk.length === 0) return
-            this.readLatch.unsafeClose()
-            for (const item of chunk) {
-              if (typeof item === "string") {
-                this.push(item, "utf8")
-              } else {
-                this.push(item)
-              }
-            }
-          })))
-      )
-    )
-    this.fiber.addObserver((exit) => {
-      this.fiber = undefined
-      if (Exit.isSuccess(exit)) {
-        this.push(null)
-      } else {
-        this.destroy(Cause.squash(exit.cause) as any)
-      }
-    })
-  }
-
-  _read(_size: number): void {
-    this.readLatch.unsafeOpen()
-  }
-
-  _destroy(error: Error | null, callback: (error?: Error | null | undefined) => void): void {
-    if (!this.fiber) {
-      return callback(error)
-    }
-    Effect.runFork(Fiber.interrupt(this.fiber)).addObserver((exit) => {
-      callback(exit._tag === "Failure" ? Cause.squash(exit.cause) as any : error)
-    })
-  }
-}
-
-/** @internal */
-export const toReadable = <E, R>(
-  stream: Stream.Stream<Uint8Array | string, E, R>
-): Effect.Effect<Readable, never, R> =>
-  Effect.map(
-    Effect.runtime<R>(),
-    (runtime) => new StreamAdapter(runtime, stream)
-  )
-
-/** @internal */
-export const toReadableNever = <E>(
-  stream: Stream.Stream<Uint8Array | string, E>
-): Readable => new StreamAdapter(Runtime.defaultRuntime, stream)