@effect/platform-node 0.22.0 → 0.23.0

package/src/internal/stream.ts

@@ -1,77 +1,42 @@
 import type { SizeInput } from "@effect/platform/FileSystem"
+import type { Cause } from "effect"
+import * as Channel from "effect/Channel"
+import type * as AsyncInput from "effect/ChannelSingleProducerAsyncInput"
+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 { pipe } from "effect/Function"
-import * as Option from "effect/Option"
+import { dual, pipe } from "effect/Function"
+import * as Queue from "effect/Queue"
 import * as Stream from "effect/Stream"
-import type { Readable } from "node:stream"
-import type { FromReadableOptions } from "../Stream"
+import type { Duplex, Readable, Writable } from "node:stream"
+import { type PlatformError, SystemError } from "../Error"
+import type { FromReadableOptions, FromWritableOptions } from "../Stream"
 
 /** @internal */
-export const fromReadable = <E, A>(
-  evaluate: LazyArg<Readable>,
+export const fromReadable = <E, A = Uint8Array>(
+  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
   onError: (error: unknown) => E,
   { chunkSize }: FromReadableOptions = {}
 ): Stream.Stream<never, E, A> =>
-  pipe(
-    Effect.acquireRelease(Effect.sync(evaluate), (stream) =>
-      Effect.sync(() => {
-        stream.removeAllListeners()
-
-        if (!stream.closed) {
-          stream.destroy()
-        }
-      })),
-    Effect.map((stream) =>
-      Stream.async<never, E, Readable>((emit) => {
-        stream.once("error", (err) => {
-          emit.fail(onError(err))
-        })
-
-        // The 'close' event is emitted after a process has ended and the stdio
-        // streams of a child process have been closed. This is distinct from
-        // the 'exit' event, since multiple processes might share the same
-        // stdio streams. The 'close' event will always emit after 'exit' was
-        // already emitted, or 'error' if the child failed to spawn.
-        stream.once("close", () => {
-          emit.end()
-        })
-
-        stream.on("readable", () => {
-          emit.single(stream)
-        })
-
-        if (stream.readable) {
-          emit.single(stream)
-        }
-      }, 1)
-    ),
-    Stream.unwrapScoped,
-    Stream.flatMap((_) => Stream.repeatEffectOption(readChunk<A>(_, chunkSize)))
-  )
-
-const readChunk = <A>(
-  stream: Readable,
-  size: SizeInput | undefined
-): Effect.Effect<never, Option.Option<never>, A> =>
-  pipe(
-    Effect.sync(() => (size ? stream.read(Number(size)) : stream.read()) as A | null),
-    Effect.flatMap((_) => (_ ? Effect.succeed(_) : Effect.fail(Option.none())))
+  Stream.fromChannel(
+    readChannel<E, A>(evaluate, onError, chunkSize ? Number(chunkSize) : undefined)
   )
 
 /** @internal */
 export const toString = <E>(
+  readable: LazyArg<Readable | NodeJS.ReadableStream>,
   options: {
-    readable: LazyArg<Readable>
-    onFailure: (error: unknown) => E
-    encoding?: BufferEncoding
-    maxBytes?: SizeInput
+    readonly onFailure: (error: unknown) => E
+    readonly encoding?: BufferEncoding
+    readonly maxBytes?: SizeInput
   }
 ): Effect.Effect<never, E, string> => {
   const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined
   return Effect.acquireUseRelease(
     Effect.sync(() => {
-      const stream = options.readable()
+      const stream = readable()
       stream.setEncoding(options.encoding ?? "utf8")
       return stream
     }),
@@ -96,7 +61,7 @@ export const toString = <E>(
     (stream) =>
       Effect.sync(() => {
         stream.removeAllListeners()
-        if (!stream.closed) {
+        if ("closed" in stream && !stream.closed) {
           stream.destroy()
         }
       })
@@ -105,15 +70,15 @@ export const toString = <E>(
 
 /** @internal */
 export const toUint8Array = <E>(
+  readable: LazyArg<Readable | NodeJS.ReadableStream>,
   options: {
-    readable: LazyArg<Readable>
-    onFailure: (error: unknown) => E
-    maxBytes?: SizeInput
+    readonly onFailure: (error: unknown) => E
+    readonly maxBytes?: SizeInput
   }
 ): Effect.Effect<never, E, Uint8Array> => {
   const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined
   return Effect.acquireUseRelease(
-    Effect.sync(options.readable),
+    Effect.sync(readable),
     (stream) =>
       Effect.async((resume) => {
         let buffer = Buffer.alloc(0)
@@ -135,9 +100,225 @@ export const toUint8Array = <E>(
     (stream) =>
       Effect.sync(() => {
         stream.removeAllListeners()
-        if (!stream.closed) {
+        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)
+        }))
+    )
+)
+
+const readChannel = <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> = pipe(
+    Channel.fromEffect(Queue.take(queue)),
+    Channel.flatMap(Either.match({
+      onLeft: Channel.fromEffect,
+      onRight: (_) => Channel.flatMap(read, () => loop)
+    }))
+  )
+  return loop
+}
+
+const readChunkChannel = <A>(
+  readable: Readable | NodeJS.ReadableStream,
+  chunkSize: number | undefined
+) =>
+  Channel.flatMap(
+    Channel.sync(() => {
+      const arr: Array<A> = []
+      let chunk = readable.read(chunkSize)
+      while (chunk !== null) {
+        arr.push(chunk)
+        chunk = readable.read(chunkSize)
+      }
+      return Chunk.unsafeFromArray(arr)
+    }),
+    Channel.write
+  )

package/dist/sink-bd7ef408.esm.js

@@ -1,34 +0,0 @@
-import * as Effect from 'effect/Effect';
-import { pipe } from 'effect/Function';
-import * as Sink from 'effect/Sink';
-
-/** @internal */
-const fromWritable = (evaluate, onError, {
-  encoding,
-  endOnClose = true
-} = {}) => endOnClose ? makeSinkWithRelease(evaluate, onError, encoding) : makeSink(evaluate, onError, encoding);
-const makeSink = (stream, onError, encoding) => pipe(Effect.sync(stream), Effect.map(stream => Sink.forEach(write(stream, onError, encoding))), Sink.unwrap);
-const makeSinkWithRelease = (stream, onError, encoding) => pipe(Effect.acquireRelease(Effect.sync(stream), endWritable), Effect.map(stream => Sink.forEach(write(stream, onError, encoding))), Sink.unwrapScoped);
-const endWritable = stream => Effect.async(resume => {
-  if (stream.closed) {
-    resume(Effect.unit);
-    return;
-  }
-  stream.end(() => resume(Effect.unit));
-});
-const write = (stream, onError, encoding) => _ => Effect.async(resume => {
-  const cb = err => {
-    if (err) {
-      resume(Effect.fail(onError(err)));
-    } else {
-      resume(Effect.unit);
-    }
-  };
-  if (encoding) {
-    stream.write(_, encoding, cb);
-  } else {
-    stream.write(_, cb);
-  }
-});
-
-export { fromWritable as f };

package/dist/sink-da49e187.cjs.prod.js

@@ -1,57 +0,0 @@
-'use strict';
-
-var Effect = require('effect/Effect');
-var Function = require('effect/Function');
-var Sink = require('effect/Sink');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
-var Sink__namespace = /*#__PURE__*/_interopNamespace(Sink);
-
-/** @internal */
-const fromWritable = (evaluate, onError, {
-  encoding,
-  endOnClose = true
-} = {}) => endOnClose ? makeSinkWithRelease(evaluate, onError, encoding) : makeSink(evaluate, onError, encoding);
-const makeSink = (stream, onError, encoding) => Function.pipe(Effect__namespace.sync(stream), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrap);
-const makeSinkWithRelease = (stream, onError, encoding) => Function.pipe(Effect__namespace.acquireRelease(Effect__namespace.sync(stream), endWritable), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrapScoped);
-const endWritable = stream => Effect__namespace.async(resume => {
-  if (stream.closed) {
-    resume(Effect__namespace.unit);
-    return;
-  }
-  stream.end(() => resume(Effect__namespace.unit));
-});
-const write = (stream, onError, encoding) => _ => Effect__namespace.async(resume => {
-  const cb = err => {
-    if (err) {
-      resume(Effect__namespace.fail(onError(err)));
-    } else {
-      resume(Effect__namespace.unit);
-    }
-  };
-  if (encoding) {
-    stream.write(_, encoding, cb);
-  } else {
-    stream.write(_, cb);
-  }
-});
-
-exports.fromWritable = fromWritable;

package/dist/sink-daf9e0e5.cjs.dev.js

@@ -1,57 +0,0 @@
-'use strict';
-
-var Effect = require('effect/Effect');
-var Function = require('effect/Function');
-var Sink = require('effect/Sink');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
-var Sink__namespace = /*#__PURE__*/_interopNamespace(Sink);
-
-/** @internal */
-const fromWritable = (evaluate, onError, {
-  encoding,
-  endOnClose = true
-} = {}) => endOnClose ? makeSinkWithRelease(evaluate, onError, encoding) : makeSink(evaluate, onError, encoding);
-const makeSink = (stream, onError, encoding) => Function.pipe(Effect__namespace.sync(stream), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrap);
-const makeSinkWithRelease = (stream, onError, encoding) => Function.pipe(Effect__namespace.acquireRelease(Effect__namespace.sync(stream), endWritable), Effect__namespace.map(stream => Sink__namespace.forEach(write(stream, onError, encoding))), Sink__namespace.unwrapScoped);
-const endWritable = stream => Effect__namespace.async(resume => {
-  if (stream.closed) {
-    resume(Effect__namespace.unit);
-    return;
-  }
-  stream.end(() => resume(Effect__namespace.unit));
-});
-const write = (stream, onError, encoding) => _ => Effect__namespace.async(resume => {
-  const cb = err => {
-    if (err) {
-      resume(Effect__namespace.fail(onError(err)));
-    } else {
-      resume(Effect__namespace.unit);
-    }
-  };
-  if (encoding) {
-    stream.write(_, encoding, cb);
-  } else {
-    stream.write(_, cb);
-  }
-});
-
-exports.fromWritable = fromWritable;

package/dist/stream-1456ece0.cjs.dev.js

@@ -1,120 +0,0 @@
-'use strict';
-
-var Effect = require('effect/Effect');
-var Function = require('effect/Function');
-var Option = require('effect/Option');
-var Stream = require('effect/Stream');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
-var Option__namespace = /*#__PURE__*/_interopNamespace(Option);
-var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
-
-/** @internal */
-const fromReadable = (evaluate, onError, {
-  chunkSize
-} = {}) => Function.pipe(Effect__namespace.acquireRelease(Effect__namespace.sync(evaluate), stream => Effect__namespace.sync(() => {
-  stream.removeAllListeners();
-  if (!stream.closed) {
-    stream.destroy();
-  }
-})), Effect__namespace.map(stream => Stream__namespace.async(emit => {
-  stream.once("error", err => {
-    emit.fail(onError(err));
-  });
-
-  // The 'close' event is emitted after a process has ended and the stdio
-  // streams of a child process have been closed. This is distinct from
-  // the 'exit' event, since multiple processes might share the same
-  // stdio streams. The 'close' event will always emit after 'exit' was
-  // already emitted, or 'error' if the child failed to spawn.
-  stream.once("close", () => {
-    emit.end();
-  });
-  stream.on("readable", () => {
-    emit.single(stream);
-  });
-  if (stream.readable) {
-    emit.single(stream);
-  }
-}, 1)), Stream__namespace.unwrapScoped, Stream__namespace.flatMap(_ => Stream__namespace.repeatEffectOption(readChunk(_, chunkSize))));
-const readChunk = (stream, size) => Function.pipe(Effect__namespace.sync(() => size ? stream.read(Number(size)) : stream.read()), Effect__namespace.flatMap(_ => _ ? Effect__namespace.succeed(_) : Effect__namespace.fail(Option__namespace.none())));
-
-/** @internal */
-const toString = options => {
-  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
-  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
-    const stream = options.readable();
-    stream.setEncoding(options.encoding ?? "utf8");
-    return stream;
-  }), stream => Effect__namespace.async(resume => {
-    let string = "";
-    let bytes = 0;
-    stream.once("error", err => {
-      resume(Effect__namespace.fail(options.onFailure(err)));
-    });
-    stream.once("end", () => {
-      resume(Effect__namespace.succeed(string));
-    });
-    stream.on("data", chunk => {
-      string += chunk;
-      bytes += Buffer.byteLength(chunk);
-      if (maxBytesNumber && bytes > maxBytesNumber) {
-        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
-      }
-    });
-  }), stream => Effect__namespace.sync(() => {
-    stream.removeAllListeners();
-    if (!stream.closed) {
-      stream.destroy();
-    }
-  }));
-};
-
-/** @internal */
-const toUint8Array = options => {
-  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
-  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(options.readable), stream => Effect__namespace.async(resume => {
-    let buffer = Buffer.alloc(0);
-    let bytes = 0;
-    stream.once("error", err => {
-      resume(Effect__namespace.fail(options.onFailure(err)));
-    });
-    stream.once("end", () => {
-      resume(Effect__namespace.succeed(buffer));
-    });
-    stream.on("data", chunk => {
-      buffer = Buffer.concat([buffer, chunk]);
-      bytes += chunk.length;
-      if (maxBytesNumber && bytes > maxBytesNumber) {
-        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
-      }
-    });
-  }), stream => Effect__namespace.sync(() => {
-    stream.removeAllListeners();
-    if (!stream.closed) {
-      stream.destroy();
-    }
-  }));
-};
-
-exports.fromReadable = fromReadable;
-exports.toString = toString;
-exports.toUint8Array = toUint8Array;