eoapi-cdk 5.4.0 → 6.0.0

package/node_modules/duplexify/test.js

@@ -0,0 +1,295 @@
+var tape = require('tape')
+var through = require('through2')
+var concat = require('concat-stream')
+var net = require('net')
+var duplexify = require('./')
+
+var HELLO_WORLD = (Buffer.from && Buffer.from !== Uint8Array.from)
+ ? Buffer.from('hello world')
+ : new Buffer('hello world')
+
+tape('passthrough', function(t) {
+  t.plan(2)
+
+  var pt = through()
+  var dup = duplexify(pt, pt)
+
+  dup.end('hello world')
+  dup.on('finish', function() {
+    t.ok(true, 'should finish')
+  })
+  dup.pipe(concat(function(data) {
+    t.same(data.toString(), 'hello world', 'same in as out')
+  }))
+})
+
+tape('passthrough + double end', function(t) {
+  t.plan(2)
+
+  var pt = through()
+  var dup = duplexify(pt, pt)
+
+  dup.end('hello world')
+  dup.end()
+
+  dup.on('finish', function() {
+    t.ok(true, 'should finish')
+  })
+  dup.pipe(concat(function(data) {
+    t.same(data.toString(), 'hello world', 'same in as out')
+  }))
+})
+
+tape('async passthrough + end', function(t) {
+  t.plan(2)
+
+  var pt = through.obj({highWaterMark:1}, function(data, enc, cb) {
+    setTimeout(function() {
+      cb(null, data)
+    }, 100)
+  })
+
+  var dup = duplexify(pt, pt)
+
+  dup.write('hello ')
+  dup.write('world')
+  dup.end()
+
+  dup.on('finish', function() {
+    t.ok(true, 'should finish')
+  })
+  dup.pipe(concat(function(data) {
+    t.same(data.toString(), 'hello world', 'same in as out')
+  }))
+})
+
+tape('duplex', function(t) {
+  var readExpected = ['read-a', 'read-b', 'read-c']
+  var writeExpected = ['write-a', 'write-b', 'write-c']
+
+  t.plan(readExpected.length+writeExpected.length+2)
+
+  var readable = through.obj()
+  var writable = through.obj(function(data, enc, cb) {
+    t.same(data, writeExpected.shift(), 'onwrite should match')
+    cb()
+  })
+
+  var dup = duplexify.obj(writable, readable)
+
+  readExpected.slice().forEach(function(data) {
+    readable.write(data)
+  })
+  readable.end()
+
+  writeExpected.slice().forEach(function(data) {
+    dup.write(data)
+  })
+  dup.end()
+
+  dup.on('data', function(data) {
+    t.same(data, readExpected.shift(), 'ondata should match')
+  })
+  dup.on('end', function() {
+    t.ok(true, 'should end')
+  })
+  dup.on('finish', function() {
+    t.ok(true, 'should finish')
+  })
+})
+
+tape('async', function(t) {
+  var dup = duplexify()
+  var pt = through()
+
+  dup.pipe(concat(function(data) {
+    t.same(data.toString(), 'i was async', 'same in as out')
+    t.end()
+  }))
+
+  dup.write('i')
+  dup.write(' was ')
+  dup.end('async')
+
+  setTimeout(function() {
+    dup.setWritable(pt)
+    setTimeout(function() {
+      dup.setReadable(pt)
+    }, 50)
+  }, 50)
+})
+
+tape('destroy', function(t) {
+  t.plan(2)
+
+  var write = through()
+  var read = through()
+  var dup = duplexify(write, read)
+
+  write.destroy = function() {
+    t.ok(true, 'write destroyed')
+  }
+
+  dup.on('close', function() {
+    t.ok(true, 'close emitted')
+  })
+
+  dup.destroy()
+  dup.destroy() // should only work once
+})
+
+tape('destroy both', function(t) {
+  t.plan(3)
+
+  var write = through()
+  var read = through()
+  var dup = duplexify(write, read)
+
+  write.destroy = function() {
+    t.ok(true, 'write destroyed')
+  }
+
+  read.destroy = function() {
+    t.ok(true, 'read destroyed')
+  }
+
+  dup.on('close', function() {
+    t.ok(true, 'close emitted')
+  })
+
+  dup.destroy()
+  dup.destroy() // should only work once
+})
+
+tape('bubble read errors', function(t) {
+  t.plan(2)
+
+  var write = through()
+  var read = through()
+  var dup = duplexify(write, read)
+
+  dup.on('error', function(err) {
+    t.same(err.message, 'read-error', 'received read error')
+  })
+  dup.on('close', function() {
+    t.ok(true, 'close emitted')
+  })
+
+  read.emit('error', new Error('read-error'))
+  write.emit('error', new Error('write-error')) // only emit first error
+})
+
+tape('bubble write errors', function(t) {
+  t.plan(2)
+
+  var write = through()
+  var read = through()
+  var dup = duplexify(write, read)
+
+  dup.on('error', function(err) {
+    t.same(err.message, 'write-error', 'received write error')
+  })
+  dup.on('close', function() {
+    t.ok(true, 'close emitted')
+  })
+
+  write.emit('error', new Error('write-error'))
+  read.emit('error', new Error('read-error')) // only emit first error
+})
+
+tape('reset writable / readable', function(t) {
+  t.plan(3)
+
+  var toUpperCase = function(data, enc, cb) {
+    cb(null, data.toString().toUpperCase())
+  }
+
+  var passthrough = through()
+  var upper = through(toUpperCase)
+  var dup = duplexify(passthrough, passthrough)
+
+  dup.once('data', function(data) {
+    t.same(data.toString(), 'hello')
+    dup.setWritable(upper)
+    dup.setReadable(upper)
+    dup.once('data', function(data) {
+      t.same(data.toString(), 'HELLO')
+      dup.once('data', function(data) {
+        t.same(data.toString(), 'HI')
+        t.end()
+      })
+    })
+    dup.write('hello')
+    dup.write('hi')
+  })
+  dup.write('hello')
+})
+
+tape('cork', function(t) {
+  var passthrough = through()
+  var dup = duplexify(passthrough, passthrough)
+  var ok = false
+
+  dup.on('prefinish', function() {
+    dup.cork()
+    setTimeout(function() {
+      ok = true
+      dup.uncork()
+    }, 100)
+  })
+  dup.on('finish', function() {
+    t.ok(ok)
+    t.end()
+  })
+  dup.end()
+})
+
+tape('prefinish not twice', function(t) {
+  var passthrough = through()
+  var dup = duplexify(passthrough, passthrough)
+  var prefinished = false
+
+  dup.on('prefinish', function() {
+    t.ok(!prefinished, 'only prefinish once')
+    prefinished = true
+  })
+
+  dup.on('finish', function() {
+    t.end()
+  })
+
+  dup.end()
+})
+
+tape('close', function(t) {
+  var passthrough = through()
+  var dup = duplexify(passthrough, passthrough)
+
+  passthrough.emit('close')
+  dup.on('close', function() {
+    t.ok(true, 'should forward close')
+    t.end()
+  })
+})
+
+tape('works with node native streams (net)', function(t) {
+  t.plan(1)
+
+  var server = net.createServer(function(socket) {
+    var dup = duplexify(socket, socket)
+
+    dup.once('data', function(chunk) {
+      t.same(chunk, HELLO_WORLD)
+      server.close()
+      socket.end()
+      t.end()
+    })
+  })
+
+  server.listen(0, function () {
+    var socket = net.connect(server.address().port)
+    var dup = duplexify(socket, socket)
+
+    dup.write(HELLO_WORLD)
+  })
+})

package/node_modules/end-of-stream/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mathias Buus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/end-of-stream/README.md

@@ -0,0 +1,54 @@
+# end-of-stream
+
+A node module that calls a callback when a readable/writable/duplex stream has completed or failed.
+
+	npm install end-of-stream
+
+[![Build status](https://travis-ci.org/mafintosh/end-of-stream.svg?branch=master)](https://travis-ci.org/mafintosh/end-of-stream)
+
+## Usage
+
+Simply pass a stream and a callback to the `eos`.
+Both legacy streams, streams2 and stream3 are supported.
+
+``` js
+var eos = require('end-of-stream');
+
+eos(readableStream, function(err) {
+  // this will be set to the stream instance
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has ended', this === readableStream);
+});
+
+eos(writableStream, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has finished', this === writableStream);
+});
+
+eos(duplexStream, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has ended and finished', this === duplexStream);
+});
+
+eos(duplexStream, {readable:false}, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has finished but might still be readable');
+});
+
+eos(duplexStream, {writable:false}, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has ended but might still be writable');
+});
+
+eos(readableStream, {error:false}, function(err) {
+	// do not treat emit('error', err) as a end-of-stream
+});
+```
+
+## License
+
+MIT
+
+## Related
+
+`end-of-stream` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.

package/node_modules/end-of-stream/index.js

@@ -0,0 +1,94 @@
+var once = require('once');
+
+var noop = function() {};
+
+var isRequest = function(stream) {
+	return stream.setHeader && typeof stream.abort === 'function';
+};
+
+var isChildProcess = function(stream) {
+	return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
+};
+
+var eos = function(stream, opts, callback) {
+	if (typeof opts === 'function') return eos(stream, null, opts);
+	if (!opts) opts = {};
+
+	callback = once(callback || noop);
+
+	var ws = stream._writableState;
+	var rs = stream._readableState;
+	var readable = opts.readable || (opts.readable !== false && stream.readable);
+	var writable = opts.writable || (opts.writable !== false && stream.writable);
+	var cancelled = false;
+
+	var onlegacyfinish = function() {
+		if (!stream.writable) onfinish();
+	};
+
+	var onfinish = function() {
+		writable = false;
+		if (!readable) callback.call(stream);
+	};
+
+	var onend = function() {
+		readable = false;
+		if (!writable) callback.call(stream);
+	};
+
+	var onexit = function(exitCode) {
+		callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
+	};
+
+	var onerror = function(err) {
+		callback.call(stream, err);
+	};
+
+	var onclose = function() {
+		process.nextTick(onclosenexttick);
+	};
+
+	var onclosenexttick = function() {
+		if (cancelled) return;
+		if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));
+		if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close'));
+	};
+
+	var onrequest = function() {
+		stream.req.on('finish', onfinish);
+	};
+
+	if (isRequest(stream)) {
+		stream.on('complete', onfinish);
+		stream.on('abort', onclose);
+		if (stream.req) onrequest();
+		else stream.on('request', onrequest);
+	} else if (writable && !ws) { // legacy streams
+		stream.on('end', onlegacyfinish);
+		stream.on('close', onlegacyfinish);
+	}
+
+	if (isChildProcess(stream)) stream.on('exit', onexit);
+
+	stream.on('end', onend);
+	stream.on('finish', onfinish);
+	if (opts.error !== false) stream.on('error', onerror);
+	stream.on('close', onclose);
+
+	return function() {
+		cancelled = true;
+		stream.removeListener('complete', onfinish);
+		stream.removeListener('abort', onclose);
+		stream.removeListener('request', onrequest);
+		if (stream.req) stream.req.removeListener('finish', onfinish);
+		stream.removeListener('end', onlegacyfinish);
+		stream.removeListener('close', onlegacyfinish);
+		stream.removeListener('finish', onfinish);
+		stream.removeListener('exit', onexit);
+		stream.removeListener('end', onend);
+		stream.removeListener('error', onerror);
+		stream.removeListener('close', onclose);
+	};
+};
+
+module.exports = eos;

package/node_modules/end-of-stream/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "end-of-stream",
+  "version": "1.4.4",
+  "description": "Call a callback when a readable/writable/duplex stream has completed or failed.",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mafintosh/end-of-stream.git"
+  },
+  "dependencies": {
+    "once": "^1.4.0"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "stream",
+    "streams",
+    "callback",
+    "finish",
+    "close",
+    "end",
+    "wait"
+  ],
+  "bugs": {
+    "url": "https://github.com/mafintosh/end-of-stream/issues"
+  },
+  "homepage": "https://github.com/mafintosh/end-of-stream",
+  "main": "index.js",
+  "author": "Mathias Buus <mathiasbuus@gmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "tape": "^4.11.0"
+  }
+}

package/node_modules/error-ex/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 JD Ballard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/error-ex/README.md

@@ -0,0 +1,144 @@
+# node-error-ex [![Travis-CI.org Build Status](https://img.shields.io/travis/Qix-/node-error-ex.svg?style=flat-square)](https://travis-ci.org/Qix-/node-error-ex) [![Coveralls.io Coverage Rating](https://img.shields.io/coveralls/Qix-/node-error-ex.svg?style=flat-square)](https://coveralls.io/r/Qix-/node-error-ex)
+> Easily subclass and customize new Error types
+
+## Examples
+To include in your project:
+```javascript
+var errorEx = require('error-ex');
+```
+
+To create an error message type with a specific name (note, that `ErrorFn.name`
+will not reflect this):
+```javascript
+var JSONError = errorEx('JSONError');
+
+var err = new JSONError('error');
+err.name; //-> JSONError
+throw err; //-> JSONError: error
+```
+
+To add a stack line:
+```javascript
+var JSONError = errorEx('JSONError', {fileName: errorEx.line('in %s')});
+
+var err = new JSONError('error')
+err.fileName = '/a/b/c/foo.json';
+throw err; //-> (line 2)-> in /a/b/c/foo.json
+```
+
+To append to the error message:
+```javascript
+var JSONError = errorEx('JSONError', {fileName: errorEx.append('in %s')});
+
+var err = new JSONError('error');
+err.fileName = '/a/b/c/foo.json';
+throw err; //-> JSONError: error in /a/b/c/foo.json
+```
+
+## API
+
+#### `errorEx([name], [properties])`
+Creates a new ErrorEx error type
+
+- `name`: the name of the new type (appears in the error message upon throw;
+  defaults to `Error.name`)
+- `properties`: if supplied, used as a key/value dictionary of properties to
+  use when building up the stack message. Keys are property names that are
+  looked up on the error message, and then passed to function values.
+	- `line`: if specified and is a function, return value is added as a stack
+    entry (error-ex will indent for you). Passed the property value given
+    the key.
+  - `stack`: if specified and is a function, passed the value of the property
+    using the key, and the raw stack lines as a second argument. Takes no
+    return value (but the stack can be modified directly).
+  - `message`: if specified and is a function, return value is used as new
+    `.message` value upon get. Passed the property value of the property named
+    by key, and the existing message is passed as the second argument as an
+    array of lines (suitable for multi-line messages).
+
+Returns a constructor (Function) that can be used just like the regular Error
+constructor.
+
+```javascript
+var errorEx = require('error-ex');
+
+var BasicError = errorEx();
+
+var NamedError = errorEx('NamedError');
+
+// --
+
+var AdvancedError = errorEx('AdvancedError', {
+	foo: {
+		line: function (value, stack) {
+			if (value) {
+				return 'bar ' + value;
+			}
+			return null;
+		}
+	}
+}
+
+var err = new AdvancedError('hello, world');
+err.foo = 'baz';
+throw err;
+
+/*
+	AdvancedError: hello, world
+	    bar baz
+	    at tryReadme() (readme.js:20:1)
+*/
+```
+
+#### `errorEx.line(str)`
+Creates a stack line using a delimiter
+
+> This is a helper function. It is to be used in lieu of writing a value object
+> for `properties` values.
+
+- `str`: The string to create
+  - Use the delimiter `%s` to specify where in the string the value should go
+
+```javascript
+var errorEx = require('error-ex');
+
+var FileError = errorEx('FileError', {fileName: errorEx.line('in %s')});
+
+var err = new FileError('problem reading file');
+err.fileName = '/a/b/c/d/foo.js';
+throw err;
+
+/*
+	FileError: problem reading file
+	    in /a/b/c/d/foo.js
+	    at tryReadme() (readme.js:7:1)
+*/
+```
+
+#### `errorEx.append(str)`
+Appends to the `error.message` string
+
+> This is a helper function. It is to be used in lieu of writing a value object
+> for `properties` values.
+
+- `str`: The string to append
+  - Use the delimiter `%s` to specify where in the string the value should go
+
+```javascript
+var errorEx = require('error-ex');
+
+var SyntaxError = errorEx('SyntaxError', {fileName: errorEx.append('in %s')});
+
+var err = new SyntaxError('improper indentation');
+err.fileName = '/a/b/c/d/foo.js';
+throw err;
+
+/*
+	SyntaxError: improper indentation in /a/b/c/d/foo.js
+	    at tryReadme() (readme.js:7:1)
+*/
+```
+
+## License
+Licensed under the [MIT License](http://opensource.org/licenses/MIT).
+You can find a copy of it in [LICENSE](LICENSE).