Tests

src/functions/baseFunctions.ts

@@ -19,4 +19,4 @@ export { replace } from "./replace";
 export { split } from "./split";
 export { stringify } from "./stringify";
 export { unbatch } from "./unbatch";
-export { compose, composeDuplex } from "./compose";
+export { compose } from "./compose";

src/functions/compose.ts

@@ -2,7 +2,6 @@ import {
     pipeline,
     Transform,
     Writable,
-    Pipe,
     WritableOptions,
     Readable,
     Duplex,
@@ -12,7 +11,6 @@ import {
  * Return a Readable stream of readable streams concatenated together
  * @param streams Readable streams to concatenate
  */
-
 // First Readable --> Readable
 // First Transform | Duplex, Last Writable --> Writable
 //
@@ -22,26 +20,23 @@ export function compose(
 ): Duplex {
     // Maybe just return a new stream here
     if (streams.length < 2) {
-        throw new Error("Not enough");
+        throw new Error("At least two streams are required to compose");
     }
 
+    const first = streams[0] as Writable;
+    const last = streams[streams.length - 1] as Readable;
     const duplex = new Duplex({
-        objectMode: true,
+        ...options,
         write(chunk, enc, cb) {
-            const first = streams[0] as Writable;
             if (!first.write(chunk)) {
-                first.on("drain", cb);
+                first.once("drain", cb);
             } else {
                 cb();
             }
         },
         read(size) {
-            let chunk;
+            if (last.readable) {
-            while (
+                this.push(last.read(size));
-                null !==
-                (chunk = (streams[streams.length - 1] as Readable).read())
-            ) {
-                this.push(chunk);
             }
         },
     });

src/functions/index.ts

@@ -297,9 +297,3 @@ export function compose(
         options,
     );
 }
-export function composeDuplex(
-    streams: Array<Writable | Transform>,
-    options?: WritableOptions,
-) {
-    return baseFunctions.composeDuplex(streams, options);
-}

src/index.ts

@@ -22,5 +22,4 @@ export {
     accumulator,
     accumulatorBy,
     compose,
-    composeDuplex,
 } from "./functions";

tests/compose.spec.ts

@@ -1,54 +1,68 @@
 const test = require("ava");
+const { expect } = require("chai");
 const { compose, composeDuplex, map } = require("../src");
 
-test.cb("compose()", t => {
+test.cb("compose() chains two streams together in the correct order", t => {
-    const first = map((chunk: number) => chunk + "x");
+    t.plan(3);
-    const second = map((chunk: number) => chunk + "y");
+    let i = 0;
+    const first = map((chunk: number) => chunk + 1);
+    const second = map((chunk: number) => chunk * 2);
 
     const composed = compose(
         [first, second],
         { objectMode: true },
     );
-    const third = map((chunk: number) => chunk + "z");
-    composed
-        .pipe(third)
-        .on("data", data => console.log("Piped composed: ", data));
 
     composed.on("data", data => {
-        console.log("data on composed", data);
+        expect(data).to.equal(result[i]);
+        t.pass();
+        i++;
+        if (i === 3) {
+            t.end();
+        }
+    });
+    composed.on("error", err => {
+        t.end(err);
+    });
+    composed.on("end", () => {
         t.end();
     });
-    composed.on("error", data => {
-        console.log("ERROR", data);
-    });
-    composed.on("end", data => {
-        console.log("end", data);
-    });
 
-    composed.write(1);
+    const input = [1, 2, 3];
-    composed.write(2);
+    const result = [4, 6, 8];
+
+    input.forEach(item => composed.write(item));
 });
-test.cb.only("composeDuplex()", t => {
-    const first = map((chunk: number) => chunk + "x");
-    const second = map((chunk: number) => chunk + "y");
 
-    const composed = composeDuplex([first, second], { objectMode: true });
+test.cb(
-    const third = map((chunk: number) => chunk + "z");
+    "compose() followed by pipe chains streams together in the correct order",
-    // composed
+    t => {
-    // .pipe(third)
+        t.plan(3);
-    // .on("data", data => console.log("Piped composed: ", data));
+        let i = 0;
+        const first = map((chunk: number) => chunk + 1);
+        const second = map((chunk: number) => chunk * 2);
 
-    composed.on("data", data => {
+        const composed = compose(
-        console.log("data on composed", data);
+            [first, second],
-        t.end();
+            { objectMode: true },
-    });
+        );
-    composed.on("error", data => {
+        const third = map((chunk: number) => chunk + 1);
-        console.log("ERROR", data);
+        composed.pipe(third).on("data", data => {
-    });
+            expect(data).to.equal(result[i]);
-    composed.on("end", data => {
+            t.pass();
-        console.log("end", data);
+            i++;
-    });
+            if (i === 3) {
+                t.end();
+            }
+        });
 
-    composed.write(1);
+        composed.on("error", err => {
-    composed.write(2);
+            t.end(err);
-});
+        });
+
+        const input = [1, 2, 3];
+        const result = [5, 7, 9];
+
+        input.forEach(item => composed.write(item));
+    },
+);