@effect/platform-node 0.21.0 → 0.22.1

package/src/Stream.ts

@@ -2,10 +2,13 @@
  * @since 1.0.0
  */
 import type { SizeInput } from "@effect/platform/FileSystem"
+import type { Channel } from "effect/Channel"
+import type { Chunk } from "effect/Chunk"
 import type { Effect } from "effect/Effect"
 import type { LazyArg } from "effect/Function"
 import type { Stream } from "effect/Stream"
-import type { Readable } from "stream"
+import type { Duplex, Readable } from "stream"
+import type { PlatformError } from "./Error"
 import * as internal from "./internal/stream"
 
 /**
@@ -17,16 +20,62 @@ export interface FromReadableOptions {
   readonly chunkSize?: SizeInput
 }
 
+/**
+ * @category model
+ * @since 1.0.0
+ */
+export interface FromWritableOptions {
+  readonly endOnDone?: boolean
+  readonly encoding?: BufferEncoding
+}
+
 /**
  * @category constructors
  * @since 1.0.0
  */
-export const fromReadable: <E, A>(
+export const fromReadable: <E, A = Uint8Array>(
   evaluate: LazyArg<Readable>,
   onError: (error: unknown) => E,
-  options?: FromReadableOptions
+  { chunkSize }?: FromReadableOptions
 ) => Stream<never, E, A> = internal.fromReadable
 
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+export const fromDuplex: <IE, E, I = Uint8Array, O = Uint8Array>(
+  evaluate: LazyArg<Duplex>,
+  onError: (error: unknown) => E,
+  options?: FromReadableOptions & FromWritableOptions
+) => Channel<never, IE, Chunk<I>, unknown, IE | E, Chunk<O>, void> = internal.fromDuplex
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+export const pipeThroughDuplex: {
+  <E2, B = Uint8Array>(
+    duplex: LazyArg<Duplex>,
+    onError: (error: unknown) => E2,
+    options?: FromReadableOptions & FromWritableOptions
+  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, B>
+  <R, E, A, E2, B = Uint8Array>(
+    self: Stream<R, E, A>,
+    duplex: LazyArg<Duplex>,
+    onError: (error: unknown) => E2,
+    options?: FromReadableOptions & FromWritableOptions
+  ): Stream<R, E | E2, B>
+} = internal.pipeThroughDuplex
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+export const pipeThroughSimple: {
+  (duplex: LazyArg<Duplex>): <R, E>(self: Stream<R, E, string | Uint8Array>) => Stream<R, E | PlatformError, Uint8Array>
+  <R, E>(self: Stream<R, E, string | Uint8Array>, duplex: LazyArg<Duplex>): Stream<R, PlatformError | E, Uint8Array>
+} = internal.pipeThroughSimple
+
 /**
  * @since 1.0.0
  * @category conversions

package/src/internal/sink.ts

@@ -1,61 +1,41 @@
+import * as Channel from "effect/Channel"
+import type * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
 import type { LazyArg } from "effect/Function"
-import { pipe } from "effect/Function"
 import * as Sink from "effect/Sink"
 import type { Writable } from "node:stream"
-import type { FromWritableOptions } from "../Sink"
+import type { FromWritableOptions } from "../Stream"
+import { writeEffect } from "./stream"
 
 /** @internal */
-export const fromWritable = <E, A>(
+export const fromWritable = <E, A = Uint8Array>(
   evaluate: LazyArg<Writable>,
   onError: (error: unknown) => E,
-  { encoding, endOnClose = true }: FromWritableOptions = {}
+  options: FromWritableOptions = {}
 ): Sink.Sink<never, E, A, never, void> =>
-  endOnClose ?
-    makeSinkWithRelease<E, A>(evaluate, onError, encoding) :
-    makeSink<E, A>(evaluate, onError, encoding)
+  Sink.suspend(() => Sink.fromChannel(writeChannel(evaluate(), onError, options)))
 
-const makeSink = <E, A>(stream: LazyArg<Writable>, onError: (error: unknown) => E, encoding?: BufferEncoding) =>
-  pipe(
-    Effect.sync(stream),
-    Effect.map((stream) => Sink.forEach(write<E, A>(stream, onError, encoding))),
-    Sink.unwrap
-  )
-
-const makeSinkWithRelease = <E, A>(
-  stream: LazyArg<Writable>,
-  onError: (error: unknown) => E,
-  encoding?: BufferEncoding
-) =>
-  pipe(
-    Effect.acquireRelease(Effect.sync(stream), endWritable),
-    Effect.map((stream) => Sink.forEach(write<E, A>(stream, onError, encoding))),
-    Sink.unwrapScoped
-  )
-
-const endWritable = (stream: Writable) =>
-  Effect.async<never, never, void>((resume) => {
-    if (stream.closed) {
-      resume(Effect.unit)
-      return
-    }
-
-    stream.end(() => resume(Effect.unit))
-  })
-
-const write = <E, A>(stream: Writable, onError: (error: unknown) => E, encoding?: BufferEncoding) => (_: A) =>
-  Effect.async<never, E, void>((resume) => {
-    const cb = (err?: Error | null) => {
-      if (err) {
-        resume(Effect.fail(onError(err)))
-      } else {
+const writeChannel = <IE, OE, A>(
+  writable: Writable,
+  onError: (error: unknown) => OE,
+  { encoding, endOnDone = true }: FromWritableOptions = {}
+): Channel.Channel<never, IE, Chunk.Chunk<A>, unknown, IE | OE, Chunk.Chunk<never>, void> => {
+  const write = writeEffect(writable, onError, encoding)
+  const close = endOnDone ?
+    Effect.async<never, never, void>((resume) => {
+      if (writable.closed) {
         resume(Effect.unit)
+      } else {
+        writable.end(() => resume(Effect.unit))
       }
-    }
+    }) :
+    Channel.unit
 
-    if (encoding) {
-      stream.write(_, encoding, cb)
-    } else {
-      stream.write(_, cb)
-    }
-  })
+  const loop: Channel.Channel<never, IE, Chunk.Chunk<A>, unknown, OE | IE, Chunk.Chunk<never>, void> = Channel
+    .readWithCause({
+      onInput: (chunk: Chunk.Chunk<A>) => Channel.flatMap(Channel.fromEffect(write(chunk)), () => loop),
+      onFailure: (cause) => Channel.zipRight(close, Channel.failCause(cause)),
+      onDone: (_done) => close
+    })
+  return loop
+}

package/src/internal/stream.ts

@@ -1,62 +1,26 @@
 import type { SizeInput } from "@effect/platform/FileSystem"
+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>(
+export const fromReadable = <E, A = Uint8Array>(
   evaluate: LazyArg<Readable>,
   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 */
@@ -141,3 +105,220 @@ export const toUint8Array = <E>(
       })
   )
 }
+
+/** @internal */
+export const fromDuplex = <IE, E, I = Uint8Array, 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, queue, onError, 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>,
+  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 (!readable.closed) {
+            readable.destroy()
+          }
+        }),
+        Queue.shutdown(queue)
+      )
+  )
+
+const writeInput = <IE, E, A>(
+  writable: Writable,
+  queue: Queue.Queue<Either.Either<Exit.Exit<IE | E, void>, void>>,
+  onError: (error: unknown) => E,
+  { encoding, endOnDone = true }: FromWritableOptions = {}
+): AsyncInput.AsyncInputProducer<IE, Chunk.Chunk<A>, unknown> => {
+  const write = writeEffect(writable, onError, encoding)
+  const close = endOnDone ?
+    Effect.async<never, never, void>((resume) => {
+      if (writable.closed) {
+        resume(Effect.unit)
+      } else {
+        writable.end(() => resume(Effect.unit))
+      }
+    }) :
+    Effect.unit
+  return {
+    awaitRead: () => Effect.unit,
+    emit: (chunk) =>
+      Effect.catchAllCause(
+        write(chunk),
+        (cause) => Queue.offer(queue, Either.left(Exit.failCause(cause)))
+      ),
+    error: (cause) =>
+      Effect.zipRight(
+        close,
+        Queue.offer(queue, Either.left(Exit.failCause(cause)))
+      ),
+    done: (_) => close
+  }
+}
+
+/** @internal */
+export const writeEffect =
+  <E, A>(writable: Writable, onError: (error: unknown) => E, encoding?: BufferEncoding) => (chunk: Chunk.Chunk<A>) =>
+    Effect.async<never, E, void>((resume) => {
+      const iterator = chunk[Symbol.iterator]()
+      function loop() {
+        const item = iterator.next()
+        if (item.done) {
+          resume(Effect.unit)
+        } else if (encoding) {
+          writable.write(item.value, encoding, onDone)
+        } else {
+          writable.write(item.value, onDone)
+        }
+      }
+      function onDone(err: unknown) {
+        if (err) {
+          resume(Effect.fail(onError(err)))
+        } else {
+          loop()
+        }
+      }
+      loop()
+    })
+
+const readableOffer = <E>(
+  readable: Readable,
+  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,
+  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,
+  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/src/tsconfig.json

@@ -0,0 +1,48 @@
+{
+  "compilerOptions": {
+    "moduleDetection": "force",
+    "downlevelIteration": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "preserveSymlinks": true,
+    "moduleResolution": "NodeNext",
+    "lib": [
+      "ES2021",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitReturns": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "noEmitOnError": false,
+    "allowJs": false,
+    "checkJs": false,
+    "forceConsistentCasingInFileNames": true,
+    "stripInternal": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noUncheckedIndexedAccess": false,
+    "strictNullChecks": true,
+    "target": "ES2021",
+    "module": "NodeNext",
+    "incremental": true,
+    "removeComments": false,
+    "paths": {
+      "@effect/platform-node": [
+        "./index.ts"
+      ],
+      "@effect/platform-node/*": [
+        "./*.ts"
+      ]
+    }
+  },
+  "include": [
+    "**/*"
+  ]
+}

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;