@effect/platform-node 0.22.0 → 0.23.0

package/dist/stream-faaffb40.esm.js

@@ -0,0 +1,175 @@
+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 { dual, pipe } from 'effect/Function';
+import * as Queue from 'effect/Queue';
+import * as Stream from 'effect/Stream';
+import { SystemError } from '@effect/platform/Error';
+
+/** @internal */
+const fromReadable = (evaluate, onError, {
+  chunkSize
+} = {}) => Stream.fromChannel(readChannel(evaluate, onError, chunkSize ? Number(chunkSize) : undefined));
+
+/** @internal */
+const toString = (readable, options) => {
+  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 */
+const toUint8Array = (readable, options) => {
+  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 */
+const fromDuplex = (evaluate, onError, options = {}) => Channel.acquireUseRelease(Effect.tap(Effect.zip(Effect.sync(evaluate), Queue.unbounded()), ([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 */
+const pipeThroughDuplex = /*#__PURE__*/dual(args => Stream.StreamTypeId in args[0], (self, duplex, onError, options) => Stream.pipeThroughChannelOrFail(self, fromDuplex(duplex, onError, options)));
+
+/** @internal */
+const pipeThroughSimple = /*#__PURE__*/dual(2, (self, duplex) => Stream.pipeThroughChannelOrFail(self, fromDuplex(duplex, error => SystemError({
+  module: "Stream",
+  method: "pipeThroughSimple",
+  pathOrDescriptor: "",
+  reason: "Unknown",
+  message: String(error)
+}))));
+const readChannel = (evaluate, onError, chunkSize) => Channel.acquireUseRelease(Effect.tap(Effect.zip(Effect.sync(evaluate), Queue.unbounded()), ([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 */
+const writeInput = (writable, onFailure, {
+  encoding,
+  endOnDone = true
+}, onDone = Effect.unit) => {
+  const write = writeEffect(writable, encoding);
+  const close = endOnDone ? Effect.async(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 */
+const writeEffect = (writable, encoding) => chunk => chunk.length === 0 ? Effect.unit : Effect.async(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);
+    if (next.done) {
+      resume(Effect.unit);
+    } else if (success) {
+      loop();
+    } else {
+      writable.once("drain", loop);
+    }
+  }
+  loop();
+});
+const readableOffer = (readable, queue, onError) => 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 = (readable, queue, chunkSize) => {
+  const read = readChunkChannel(readable, chunkSize);
+  const loop = pipe(Channel.fromEffect(Queue.take(queue)), Channel.flatMap(Either.match({
+    onLeft: Channel.fromEffect,
+    onRight: _ => Channel.flatMap(read, () => loop)
+  })));
+  return loop;
+};
+const readChunkChannel = (readable, chunkSize) => Channel.flatMap(Channel.sync(() => {
+  const arr = [];
+  let chunk = readable.read(chunkSize);
+  while (chunk !== null) {
+    arr.push(chunk);
+    chunk = readable.read(chunkSize);
+  }
+  return Chunk.unsafeFromArray(arr);
+}), Channel.write);
+
+export { fromDuplex as a, pipeThroughSimple as b, toUint8Array as c, fromReadable as f, pipeThroughDuplex as p, toString as t, writeInput as w };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform-node",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Unified interfaces for common platform-specific services",
   "main": "dist/effect-platform-node.cjs.js",
   "module": "dist/effect-platform-node.esm.js",
@@ -36,7 +36,9 @@
     "@effect/schema": "^0.43.0",
     "@types/busboy": "^1.5.1",
     "@types/mime": "^3.0.2",
-    "effect": "2.0.0-next.48"
+    "@types/tar": "^6.1.6",
+    "effect": "2.0.0-next.48",
+    "tar": "^6.2.0"
   },
   "peerDependencies": {
     "effect": "2.0.0-next.48"
@@ -44,7 +46,7 @@
   "dependencies": {
     "busboy": "^1.6.0",
     "mime": "^3.0.0",
-    "@effect/platform": "^0.21.0"
+    "@effect/platform": "^0.22.0"
   },
   "files": [
     "src",

package/src/Sink.ts

@@ -6,22 +6,14 @@ import type { LazyArg } from "effect/Function"
 import type { Sink } from "effect/Sink"
 import type { Writable } from "stream"
 import * as internal from "./internal/sink"
-
-/**
- * @category model
- * @since 1.0.0
- */
-export interface FromWritableOptions {
-  readonly endOnClose?: boolean
-  readonly encoding?: BufferEncoding
-}
+import type { FromWritableOptions } from "./Stream"
 
 /**
  * @category constructor
  * @since 1.0.0
  */
-export const fromWritable: <E, A>(
-  evaluate: LazyArg<Writable>,
+export const fromWritable: <E, A = string | Uint8Array>(
+  evaluate: LazyArg<Writable | NodeJS.WritableStream>,
   onError: (error: unknown) => E,
   options?: FromWritableOptions
 ) => Sink<never, E, A, never, void> = internal.fromWritable

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,26 +20,72 @@ 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>(
-  evaluate: LazyArg<Readable>,
+export const fromReadable: <E, A = Uint8Array>(
+  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
   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
  */
 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 | undefined
+    readonly maxBytes?: SizeInput | undefined
   }
 ) => Effect<never, E, string> = internal.toString
 
@@ -45,9 +94,6 @@ export const toString: <E>(
  * @category conversions
  */
 export const toUint8Array: <E>(
-  options: {
-    readable: LazyArg<Readable>
-    onFailure: (error: unknown) => E
-    maxBytes?: SizeInput
-  }
+  readable: LazyArg<Readable | NodeJS.ReadableStream>,
+  options: { readonly onFailure: (error: unknown) => E; readonly maxBytes?: SizeInput | undefined }
 ) => Effect<never, E, Uint8Array> = internal.toUint8Array

package/src/internal/http/formData.ts

@@ -88,8 +88,7 @@ export const stream = (
         (part) =>
           part._tag === "File" && Chunk.some(fieldMimeTypes, (_) => part.contentType.includes(_)) ?
             Effect.map(
-              NodeStream.toString({
-                readable: () => part.source,
+              NodeStream.toString(() => part.source, {
                 onFailure: (error) => FormData.FormDataError("InternalError", error)
               }),
               (content) => new FieldImpl(part.key, part.contentType, content)

package/src/internal/http/incomingMessage.ts

@@ -37,8 +37,7 @@ export class IncomingMessageImpl<E> implements IncomingMessage.IncomingMessage<E
       Effect.flatMap(
         FiberRef.get(IncomingMessage.maxBodySize),
         (maxBodySize) =>
-          NodeStream.toString({
-            readable: () => this.source,
+          NodeStream.toString(() => this.source, {
             onFailure: this.onError,
             maxBytes: Option.getOrUndefined(maxBodySize)
           })
@@ -73,8 +72,7 @@ export class IncomingMessageImpl<E> implements IncomingMessage.IncomingMessage<E
     return Effect.flatMap(
       FiberRef.get(IncomingMessage.maxBodySize),
       (maxBodySize) =>
-        NodeStream.toUint8Array({
-          readable: () => this.source,
+        NodeStream.toUint8Array(() => this.source, {
           onFailure: this.onError,
           maxBytes: Option.getOrUndefined(maxBodySize)
         })

package/src/internal/http/nodeClient.ts

@@ -54,7 +54,7 @@ export const makeAgentLayer = (options?: Https.AgentOptions): Layer.Layer<never,
 export const agentLayer = makeAgentLayer()
 
 const fromAgent = (agent: NodeClient.HttpAgent): Client.Client.Default =>
-  Client.make((request) =>
+  Client.makeDefault((request) =>
     Effect.flatMap(
       UrlParams.makeUrl(request.url, request.urlParams, (_) =>
         Error.RequestError({

package/src/internal/http/server.ts

@@ -79,7 +79,9 @@ export const make = (
           port: address.port
         },
       serve: (httpApp, middleware) => {
-        const handledApp = middleware ? middleware(respond(httpApp)) : respond(httpApp)
+        const handledApp = middleware
+          ? middleware(App.withDefaultMiddleware(respond(httpApp)))
+          : App.withDefaultMiddleware(respond(httpApp))
         return Effect.flatMap(Effect.all([Effect.runtime(), Effect.fiberId]), ([runtime, fiberId]) => {
           const runFork = Runtime.runFork(runtime)
           function handler(nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) {

package/src/internal/sink.ts

@@ -1,61 +1,56 @@
+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 { 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 { writeInput } from "./stream"
 
 /** @internal */
-export const fromWritable = <E, A>(
-  evaluate: LazyArg<Writable>,
+export const fromWritable = <E, A = Uint8Array | string>(
+  evaluate: LazyArg<Writable | NodeJS.WritableStream>,
   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 writeChannel = <IE, OE, A>(
+  writable: 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(
+    Deferred.make<IE, void>(),
+    (deferred) => {
+      const input = writeInput<IE, A>(
+        writable,
+        (_) => Deferred.failCause(deferred, _),
+        options,
+        Deferred.complete(deferred, Effect.unit)
+      )
+      return Channel.embedInput(
+        writableOutput(writable, deferred, onError),
+        input
+      )
+    }
   )
 
-const makeSinkWithRelease = <E, A>(
-  stream: LazyArg<Writable>,
-  onError: (error: unknown) => E,
-  encoding?: BufferEncoding
+const writableOutput = <IE, E>(
+  writable: Writable | NodeJS.WritableStream,
+  deferred: Deferred.Deferred<IE, void>,
+  onError: (error: unknown) => E
 ) =>
-  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) {
+  Effect.raceFirst(
+    Effect.async<never, E, never>((resume) => {
+      function handleError(err: unknown) {
         resume(Effect.fail(onError(err)))
-      } else {
-        resume(Effect.unit)
       }
-    }
-
-    if (encoding) {
-      stream.write(_, encoding, cb)
-    } else {
-      stream.write(_, cb)
-    }
-  })
+      writable.on("error", handleError)
+      return Effect.sync(() => {
+        writable.off("error", handleError)
+      })
+    }),
+    Deferred.await(deferred)
+  )