@effect/platform-node 0.22.1 → 0.23.1

package/dist/{stream-c0c7bc20.cjs.dev.js → stream-8bbecb96.cjs.dev.js}

@@ -42,10 +42,10 @@ const fromReadable = (evaluate, onError, {
 } = {}) => Stream__namespace.fromChannel(readChannel(evaluate, onError, chunkSize ? Number(chunkSize) : undefined));
 
 /** @internal */
-const toString = options => {
+const toString = (readable, options) => {
   const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
   return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
-    const stream = options.readable();
+    const stream = readable();
     stream.setEncoding(options.encoding ?? "utf8");
     return stream;
   }), stream => Effect__namespace.async(resume => {
@@ -66,16 +66,16 @@ const toString = options => {
     });
   }), stream => Effect__namespace.sync(() => {
     stream.removeAllListeners();
-    if (!stream.closed) {
+    if ("closed" in stream && !stream.closed) {
       stream.destroy();
     }
   }));
 };
 
 /** @internal */
-const toUint8Array = options => {
+const toUint8Array = (readable, options) => {
   const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
-  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(options.readable), stream => Effect__namespace.async(resume => {
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(readable), stream => Effect__namespace.async(resume => {
     let buffer = Buffer.alloc(0);
     let bytes = 0;
     stream.once("error", err => {
@@ -93,14 +93,14 @@ const toUint8Array = options => {
     });
   }), stream => Effect__namespace.sync(() => {
     stream.removeAllListeners();
-    if (!stream.closed) {
+    if ("closed" in stream && !stream.closed) {
       stream.destroy();
     }
   }));
 };
 
 /** @internal */
-const fromDuplex = (evaluate, onError, options = {}) => Channel__namespace.acquireUseRelease(Effect__namespace.tap(Effect__namespace.zip(Effect__namespace.sync(evaluate), Queue__namespace.unbounded()), ([duplex, queue]) => readableOffer(duplex, queue, onError)), ([duplex, queue]) => Channel__namespace.embedInput(readableTake(duplex, queue, options.chunkSize ? Number(options.chunkSize) : undefined), writeInput(duplex, queue, onError, options)), ([duplex, queue]) => Effect__namespace.zipRight(Effect__namespace.sync(() => {
+const fromDuplex = (evaluate, onError, options = {}) => Channel__namespace.acquireUseRelease(Effect__namespace.tap(Effect__namespace.zip(Effect__namespace.sync(evaluate), Queue__namespace.unbounded()), ([duplex, queue]) => readableOffer(duplex, queue, onError)), ([duplex, queue]) => Channel__namespace.embedInput(readableTake(duplex, queue, options.chunkSize ? Number(options.chunkSize) : undefined), writeInput(duplex, cause => Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause))), options)), ([duplex, queue]) => Effect__namespace.zipRight(Effect__namespace.sync(() => {
   duplex.removeAllListeners();
   if (!duplex.closed) {
     duplex.destroy();
@@ -120,48 +120,47 @@ const pipeThroughSimple = /*#__PURE__*/Function.dual(2, (self, duplex) => Stream
 }))));
 const readChannel = (evaluate, onError, chunkSize) => Channel__namespace.acquireUseRelease(Effect__namespace.tap(Effect__namespace.zip(Effect__namespace.sync(evaluate), Queue__namespace.unbounded()), ([readable, queue]) => readableOffer(readable, queue, onError)), ([readable, queue]) => readableTake(readable, queue, chunkSize), ([readable, queue]) => Effect__namespace.zipRight(Effect__namespace.sync(() => {
   readable.removeAllListeners();
-  if (!readable.closed) {
+  if ("closed" in readable && !readable.closed) {
     readable.destroy();
   }
 }), Queue__namespace.shutdown(queue)));
-const writeInput = (writable, queue, onError, {
+
+/** @internal */
+const writeInput = (writable, onFailure, {
   encoding,
   endOnDone = true
-} = {}) => {
-  const write = writeEffect(writable, onError, encoding);
+}, onDone = Effect__namespace.unit) => {
+  const write = writeEffect(writable, encoding);
   const close = endOnDone ? Effect__namespace.async(resume => {
-    if (writable.closed) {
+    if ("closed" in writable && writable.closed) {
       resume(Effect__namespace.unit);
     } else {
-      writable.end(() => resume(Effect__namespace.unit));
+      writable.once("finish", () => resume(Effect__namespace.unit));
+      writable.end();
     }
   }) : Effect__namespace.unit;
   return {
     awaitRead: () => Effect__namespace.unit,
-    emit: chunk => Effect__namespace.catchAllCause(write(chunk), cause => Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause)))),
-    error: cause => Effect__namespace.zipRight(close, Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause)))),
-    done: _ => close
+    emit: write,
+    error: cause => Effect__namespace.zipRight(close, onFailure(cause)),
+    done: _ => Effect__namespace.zipRight(close, onDone)
   };
 };
 
 /** @internal */
-const writeEffect = (writable, onError, encoding) => chunk => Effect__namespace.async(resume => {
+const writeEffect = (writable, encoding) => chunk => chunk.length === 0 ? Effect__namespace.unit : Effect__namespace.async(resume => {
   const iterator = chunk[Symbol.iterator]();
+  let next = iterator.next();
   function loop() {
-    const item = iterator.next();
-    if (item.done) {
+    const item = next;
+    next = iterator.next();
+    const success = writable.write(item.value, encoding);
+    if (next.done) {
       resume(Effect__namespace.unit);
-    } else if (encoding) {
-      writable.write(item.value, encoding, onDone);
-    } else {
-      writable.write(item.value, onDone);
-    }
-  }
-  function onDone(err) {
-    if (err) {
-      resume(Effect__namespace.fail(onError(err)));
-    } else {
+    } else if (success) {
       loop();
+    } else {
+      writable.once("drain", loop);
     }
   }
   loop();
@@ -207,4 +206,4 @@ exports.pipeThroughDuplex = pipeThroughDuplex;
 exports.pipeThroughSimple = pipeThroughSimple;
 exports.toString = toString;
 exports.toUint8Array = toUint8Array;
-exports.writeEffect = writeEffect;
+exports.writeInput = writeInput;

package/dist/{stream-36ca9d0a.esm.js → stream-faaffb40.esm.js}

@@ -14,10 +14,10 @@ const fromReadable = (evaluate, onError, {
 } = {}) => Stream.fromChannel(readChannel(evaluate, onError, chunkSize ? Number(chunkSize) : undefined));
 
 /** @internal */
-const toString = options => {
+const toString = (readable, options) => {
   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;
   }), stream => Effect.async(resume => {
@@ -38,16 +38,16 @@ const toString = options => {
     });
   }), stream => Effect.sync(() => {
     stream.removeAllListeners();
-    if (!stream.closed) {
+    if ("closed" in stream && !stream.closed) {
       stream.destroy();
     }
   }));
 };
 
 /** @internal */
-const toUint8Array = options => {
+const toUint8Array = (readable, options) => {
   const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
-  return Effect.acquireUseRelease(Effect.sync(options.readable), stream => Effect.async(resume => {
+  return Effect.acquireUseRelease(Effect.sync(readable), stream => Effect.async(resume => {
     let buffer = Buffer.alloc(0);
     let bytes = 0;
     stream.once("error", err => {
@@ -65,14 +65,14 @@ const toUint8Array = options => {
     });
   }), stream => Effect.sync(() => {
     stream.removeAllListeners();
-    if (!stream.closed) {
+    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, queue, onError, options)), ([duplex, queue]) => Effect.zipRight(Effect.sync(() => {
+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();
@@ -92,48 +92,47 @@ const pipeThroughSimple = /*#__PURE__*/dual(2, (self, duplex) => Stream.pipeThro
 }))));
 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 (!readable.closed) {
+  if ("closed" in readable && !readable.closed) {
     readable.destroy();
   }
 }), Queue.shutdown(queue)));
-const writeInput = (writable, queue, onError, {
+
+/** @internal */
+const writeInput = (writable, onFailure, {
   encoding,
   endOnDone = true
-} = {}) => {
-  const write = writeEffect(writable, onError, encoding);
+}, onDone = Effect.unit) => {
+  const write = writeEffect(writable, encoding);
   const close = endOnDone ? Effect.async(resume => {
-    if (writable.closed) {
+    if ("closed" in writable && writable.closed) {
       resume(Effect.unit);
     } else {
-      writable.end(() => resume(Effect.unit));
+      writable.once("finish", () => resume(Effect.unit));
+      writable.end();
     }
   }) : 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
+    emit: write,
+    error: cause => Effect.zipRight(close, onFailure(cause)),
+    done: _ => Effect.zipRight(close, onDone)
   };
 };
 
 /** @internal */
-const writeEffect = (writable, onError, encoding) => chunk => Effect.async(resume => {
+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 = iterator.next();
-    if (item.done) {
+    const item = next;
+    next = iterator.next();
+    const success = writable.write(item.value, encoding);
+    if (next.done) {
       resume(Effect.unit);
-    } else if (encoding) {
-      writable.write(item.value, encoding, onDone);
-    } else {
-      writable.write(item.value, onDone);
-    }
-  }
-  function onDone(err) {
-    if (err) {
-      resume(Effect.fail(onError(err)));
-    } else {
+    } else if (success) {
       loop();
+    } else {
+      writable.once("drain", loop);
     }
   }
   loop();
@@ -173,4 +172,4 @@ const readChunkChannel = (readable, chunkSize) => Channel.flatMap(Channel.sync((
   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, writeEffect as w };
+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.1",
+  "version": "0.23.1",
   "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

@@ -12,8 +12,8 @@ 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

@@ -34,7 +34,7 @@ export interface FromWritableOptions {
  * @since 1.0.0
  */
 export const fromReadable: <E, A = Uint8Array>(
-  evaluate: LazyArg<Readable>,
+  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
   onError: (error: unknown) => E,
   { chunkSize }?: FromReadableOptions
 ) => Stream<never, E, A> = internal.fromReadable
@@ -81,11 +81,11 @@ export const pipeThroughSimple: {
  * @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
 
@@ -94,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,41 +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 "../Stream"
-import { writeEffect } from "./stream"
+import { writeInput } from "./stream"
 
 /** @internal */
-export const fromWritable = <E, A = Uint8Array>(
-  evaluate: LazyArg<Writable>,
+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.suspend(() => Sink.fromChannel(writeChannel(evaluate(), onError, options)))
 
 const writeChannel = <IE, OE, A>(
-  writable: Writable,
+  writable: Writable | NodeJS.WritableStream,
   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
+  options: FromWritableOptions = {}
+): Channel.Channel<never, IE, Chunk.Chunk<A>, unknown, IE | OE, Chunk.Chunk<never>, void> =>
+  Channel.flatMap(
+    Deferred.make<IE | OE, 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 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
+const writableOutput = <IE, E>(
+  writable: Writable | NodeJS.WritableStream,
+  deferred: Deferred.Deferred<IE | E, void>,
+  onError: (error: unknown) => E
+) => {
+  function handleError(err: unknown) {
+    Deferred.unsafeDone(deferred, Effect.fail(onError(err)))
+  }
+  return Effect.suspend(() => {
+    writable.on("error", handleError)
+    return Effect.ensuring(
+      Deferred.await(deferred),
+      Effect.sync(() => {
+        writable.removeListener("error", handleError)
+      })
+    )
+  })
 }