stream: add pipeline() for webstreams

Refs: #39316
PR-URL: #46307
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

Author: debadree25

doc/api/stream.md

@@ -2669,6 +2669,9 @@ const cleanup = finished(rs, (err) => {
 <!-- YAML
 added: v10.0.0
 changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/46307
+ description: Added support for webstreams.
  - version: v18.0.0
  pr-url: https://github.com/nodejs/node/pull/41678
  description: Passing an invalid callback to the `callback` argument
@@ -2685,13 +2688,14 @@ changes:
  description: Add support for async generators.
 -->
 
-*`streams` {Stream\[]|Iterable\[]|AsyncIterable\[]|Function\[]}
-*`source` {Stream|Iterable|AsyncIterable|Function}
+*`streams` {Stream\[]|Iterable\[]|AsyncIterable\[]|Function\[]|
+ ReadableStream\[]|WritableStream\[]|TransformStream\[]}
+*`source` {Stream|Iterable|AsyncIterable|Function|ReadableStream}
 * Returns: {Iterable|AsyncIterable}
-*`...transforms` {Stream|Function}
+*`...transforms` {Stream|Function|TransformStream}
 *`source` {AsyncIterable}
 * Returns: {AsyncIterable}
-*`destination` {Stream|Function}
+*`destination` {Stream|Function|WritableStream}
 *`source` {AsyncIterable}
 * Returns: {AsyncIterable|Promise}
 *`callback` {Function} Called when the pipeline is fully done.

lib/internal/streams/pipeline.js

@@ -35,6 +35,9 @@ const {
  isReadable,
  isReadableNodeStream,
  isNodeStream,
+ isTransformStream,
+ isWebStream,
+ isReadableStream,
 }=require('internal/streams/utils');
 const{ AbortController }=require('internal/abort_controller');
 
@@ -88,7 +91,7 @@ async function* fromReadable(val) {
 yield*Readable.prototype[SymbolAsyncIterator].call(val);
 }
 
-asyncfunctionpump(iterable,writable,finish,{ end }){
+asyncfunctionpumpToNode(iterable,writable,finish,{ end }){
 leterror;
 letonresolve=null;
 
@@ -147,6 +150,35 @@ async function pump(iterable, writable, finish, { end }) {
 }
 }
 
+asyncfunctionpumpToWeb(readable,writable,finish,{ end }){
+if(isTransformStream(writable)){
+writable=writable.writable;
+}
+// https://streams.spec.whatwg.org/#example-manual-write-with-backpressure
+constwriter=writable.getWriter();
+try{
+forawait(constchunkofreadable){
+awaitwriter.ready;
+writer.write(chunk).catch(()=>{});
+}
+
+awaitwriter.ready;
+
+if(end){
+awaitwriter.close();
+}
+
+finish();
+}catch(err){
+try{
+awaitwriter.abort(err);
+finish(err);
+}catch(err){
+finish(err);
+}
+}
+}
+
 functionpipeline(...streams){
 returnpipelineImpl(streams,once(popCallback(streams)));
 }
@@ -259,7 +291,11 @@ function pipelineImpl(streams, callback, opts) {
 ret=Duplex.from(stream);
 }
 }elseif(typeofstream==='function'){
-ret=makeAsyncIterable(ret);
+if(isTransformStream(ret)){
+ret=makeAsyncIterable(ret?.readable);
+}else{
+ret=makeAsyncIterable(ret);
+}
 ret=stream(ret,{ signal });
 
 if(reading){
@@ -303,7 +339,11 @@ function pipelineImpl(streams, callback, opts) {
 );
 }elseif(isIterable(ret,true)){
 finishCount++;
-pump(ret,pt,finish,{ end });
+pumpToNode(ret,pt,finish,{ end });
+}elseif(isReadableStream(ret)||isTransformStream(ret)){
+consttoRead=ret.readable||ret;
+finishCount++;
+pumpToNode(toRead,pt,finish,{ end });
 }else{
 thrownewERR_INVALID_RETURN_VALUE(
 'AsyncIterable or Promise','destination',ret);
@@ -324,12 +364,30 @@ function pipelineImpl(streams, callback, opts) {
 if(isReadable(stream)&&isLastStream){
 lastStreamCleanup.push(cleanup);
 }
+}elseif(isTransformStream(ret)||isReadableStream(ret)){
+consttoRead=ret.readable||ret;
+finishCount++;
+pumpToNode(toRead,stream,finish,{ end });
 }elseif(isIterable(ret)){
 finishCount++;
-pump(ret,stream,finish,{ end });
+pumpToNode(ret,stream,finish,{ end });
+}else{
+thrownewERR_INVALID_ARG_TYPE(
+'val',['Readable','Iterable','AsyncIterable','ReadableStream','TransformStream'],ret);
+}
+ret=stream;
+}elseif(isWebStream(stream)){
+if(isReadableNodeStream(ret)){
+finishCount++;
+pumpToWeb(makeAsyncIterable(ret),stream,finish,{ end });
+}elseif(isReadableStream(ret)||isIterable(ret)){
+finishCount++;
+pumpToWeb(ret,stream,finish,{ end });
+}elseif(isTransformStream(ret)){
+pumpToWeb(ret.readable,stream,finish,{ end });
 }else{
 thrownewERR_INVALID_ARG_TYPE(
-'val',['Readable','Iterable','AsyncIterable'],ret);
+'val',['Readable','Iterable','AsyncIterable','ReadableStream','TransformStream'],ret);
 }
 ret=stream;
 }else{

lib/internal/streams/utils.js

@@ -77,6 +77,19 @@ function isWritableStream(obj) {
 );
 }
 
+functionisTransformStream(obj){
+return!!(
+obj&&
+!isNodeStream(obj)&&
+typeofobj.readable==='object'&&
+typeofobj.writable==='object'
+);
+}
+
+functionisWebStream(obj){
+returnisReadableStream(obj)||isWritableStream(obj)||isTransformStream(obj);
+}
+
 functionisIterable(obj,isAsync){
 if(obj==null)returnfalse;
 if(isAsync===true)returntypeofobj[SymbolAsyncIterator]==='function';
@@ -303,6 +316,7 @@ module.exports = {
  isReadableFinished,
  isReadableErrored,
  isNodeStream,
+ isWebStream,
  isWritable,
  isWritableNodeStream,
  isWritableStream,
@@ -312,4 +326,5 @@ module.exports = {
  isServerRequest,
  isServerResponse,
  willEmitClose,
+ isTransformStream,
 };

lib/stream/promises.js

@@ -8,6 +8,7 @@ const {
 const{
  isIterable,
  isNodeStream,
+ isWebStream,
 }=require('internal/streams/utils');
 
 const{pipelineImpl: pl}=require('internal/streams/pipeline');
@@ -21,7 +22,7 @@ function pipeline(...streams) {
 letend;
 constlastArg=streams[streams.length-1];
 if(lastArg&&typeoflastArg==='object'&&
-!isNodeStream(lastArg)&&!isIterable(lastArg)){
+!isNodeStream(lastArg)&&!isIterable(lastArg)&&!isWebStream(lastArg)){
 constoptions=ArrayPrototypePop(streams);
 signal=options.signal;
 end=options.end;