stream-to-promise - npm Package Compare versions

Comparing version 0.0.5 to 0.1.0

index.js

@@ -1,6 +0,7 @@
-var toArray = require('stream-to-array');
-var Promise  = require('bluebird');
+var toArray   = require('stream-to-array');
+var Promise   = require('bluebird');
+var internals = {};
 
-module.exports = function (stream) {
-  var promise = Promise.promisify(toArray)(stream)
+internals.readable = function (stream) {
+  var promise = Promise.promisify(toArray)(stream);
   stream.resume();
@@ -11,6 +12,26 @@ return promise
     })
-    .then(Buffer.concat)
-    .error(function (err) {
-      throw err.cause;
-    });
-};
+    .then(Buffer.concat);
+};
+
+internals.writable = function (stream) {
+  return new Promise(function (resolve, reject) {
+    stream.once('finish', resolve);
+    stream.once('error', reject);
+  });
+}
+
+module.exports = function (stream) {
+  var promise;
+  if (stream.readable) {
+    promise = internals.readable(stream);   
+  } else if (stream.writable) {
+    promise = internals.writable(stream);
+  } else {
+    promise = Promise.resolve();
+  }
+  return promise
+    .catch(function (err) {
+      err = err.cause || err;
+      throw err;
+    });  
+};

package.json

 {
   "name": "stream-to-promise",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "description": "Convert readable streams to promises",
@@ -5,0 +5,0 @@ "main": "index.js",

README.md

 stream-to-promise [![Build Status](https://travis-ci.org/bendrucker/stream-to-promise.png)](https://travis-ci.org/bendrucker/stream-to-promise) [![NPM version](https://badge.fury.io/js/stream-to-promise.png)](http://badge.fury.io/js/stream-to-promise)
 =================
 
-Convert readable streams to promises.
+Convert streams (readable or writable) to promises
 
 
 ```js
-streamToPromise(stream).then(function (buffer) {
+streamToPromise(readableStream).then(function (buffer) {
   // buffer.length === 3
 });
-stream.emit('data', new Buffer());
-stream.emit('data', new Buffer());
-stream.emit('data', new Buffer());
-stream.emit('end'); // promise is resolved here
+readableStream.emit('data', new Buffer());
+readableStream.emit('data', new Buffer());
+readableStream.emit('data', new Buffer());
+readableStream.emit('end'); // promise is resolved here
 ```
 
 ```js
+streamToPromise(writableStream).then(function () {
+  // resolves undefined
+});
+writableStream.write('data');
+writeableStream.end(); // promise is resolved here
+```
+
+```js
 var err = new Error();
@@ -23,2 +31,2 @@ streamToPromise(stream).catch(function (error) {
 stream.emit('error', err); // promise is rejected here
-```
+```

test.js

@@ -7,2 +7,3 @@ 'use strict';
 var DelayedStream   = require('delayed-stream');
+var fs              = require('fs');
 var streamToPromise = require('./');
@@ -21,58 +22,113 @@
 
-  var stream, promise;
-  beforeEach(function () {
-    stream = new Stream.Readable();
-    stream._read = function noop () {};
-    promise = streamToPromise(stream);
-  });
+  describe('Readable streams', function () {
 
-  it('can resolve empty streams', function () {
-    stream.emit('end');
-    return promise.then(function (buffer) {
-      expect(buffer).to.be.an.instanceOf(Buffer);
-      expect(buffer).to.have.length(0);
+    var readable, promise;
+    beforeEach(function () {
+      readable = new Stream.Readable();
+      readable._read = function noop () {};
+      promise = streamToPromise(readable);
     });
-  });
 
-  it('resolves stream data', function () {
-    stream.emit('data', new Buffer('foo'));
-    stream.emit('data', new Buffer('bar'));
-    stream.emit('end');
-    return promise.then(function (buffer) {
-      expect(buffer).to.be.an.instanceOf(Buffer);
-      expect(buffer.toString()).to.equal('foobar');
+    it('can resolve empty streams', function () {
+      readable.emit('end');
+      return promise.then(function (buffer) {
+        expect(buffer).to.be.an.instanceOf(Buffer);
+        expect(buffer).to.have.length(0);
+      });
     });
-  });
 
-  it('can handle streams of buffers and strings', function () {
-    stream.emit('data', new Buffer('foo'));
-    stream.emit('data', 'bar');
-    stream.emit('end');
-    return promise.then(function (buffer) {
-      expect(buffer.toString()).to.equal('foobar');
+    it('resolves stream data', function () {
+      readable.emit('data', new Buffer('foo'));
+      readable.emit('data', new Buffer('bar'));
+      readable.emit('end');
+      return promise.then(function (buffer) {
+        expect(buffer).to.be.an.instanceOf(Buffer);
+        expect(buffer.toString()).to.equal('foobar');
+      });
     });
-  });
 
-  it('resolves immediately for ended streams', function () {
-    stream.readable = false;
-    return streamToPromise(stream).then(function (buffer) {
-      expect(buffer).to.have.length(0);
+    it('can handle streams of buffers and strings', function () {
+      readable.emit('data', new Buffer('foo'));
+      readable.emit('data', 'bar');
+      readable.emit('end');
+      return promise.then(function (buffer) {
+        expect(buffer.toString()).to.equal('foobar');
+      });
     });
+
+    it('resolves immediately for ended streams', function () {
+      readable.readable = false;
+      return streamToPromise(readable).then(function (result) {
+        expect(result).to.be.undefined;
+      });
+    });
+
+    it('ensures that streams are flowing (#1)', function () {
+      var delayed = DelayedStream.create(readable);
+      readable.emit('data', new Buffer('foo'));
+      readable.emit('end');
+      return streamToPromise(delayed).then(function (buffer) {
+        expect(buffer.toString()).to.equal('foo');
+      });
+    });
+
+    it('rejects on stream errors', function () {
+      var err = new Error();
+      readable.emit('error', err);
+      return expect(promise).to.be.rejectedWith(err);
+    });
+
   });
 
-  it('ensures that streams are flowing (#1)', function () {
-    var delayed = DelayedStream.create(stream);
-    stream.emit('data', new Buffer('foo'));
-    stream.emit('end');
-    return streamToPromise(delayed).then(function (buffer) {
-      expect(buffer.toString()).to.equal('foo');
+  describe('Writable streams (#2)', function () {
+
+    var writable, promise;
+    beforeEach(function () {
+      writable = new Stream.Writable();
+      writable._read = function noop () {};
+      promise = streamToPromise(writable);
     });
+
+    it('resolves undefined when the stream finishes', function () {
+      writable.emit('finish');
+      return expect(promise).to.eventually.be.undefined;
+    });
+
+    it('rejects on stream errors', function () {
+      var err = new Error();
+      writable.emit('error', err);
+      return expect(promise).to.be.rejectedWith(err);
+    });
+
   });
 
-  it('rejects on stream errors', function () {
-    var err = new Error();
-    stream.emit('error', err);
-    return expect(promise).to.be.rejectedWith(err);
+  describe('Integration', function () {
+
+    it('can handle an fs read stream', function () {
+      return Promise.promisify(fs.writeFile, fs)('read.txt', 'hi there!')
+        .then(function () {
+          return streamToPromise(fs.createReadStream('read.txt'));
+        })
+        .then(function (contents) {
+          expect(contents.toString()).to.equal('hi there!');
+        });
+    });
+
+    it('can handle an fs write stream', function () {
+      var stream = fs.createWriteStream('written.txt');
+      process.nextTick(function () {
+        stream.write('written contents');
+        stream.end();
+      });
+      return streamToPromise(stream)
+        .then(function () {
+          return Promise.promisify(fs.readFile, fs)('written.txt');
+        })
+        .then(function (contents) {
+          expect(contents.toString()).to.equal('written contents');
+        });
+    });
+
   });
 
-});
+});

New alerts

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

7997

increased by43.32%

Lines of code

141

increased by88%

Number of lines in readme file

32

increased by39.13%

Worsened metrics

Number of low supply chain risk alerts

1

increased byInfinity%

No dependency changes