Extend writeable stream to become transform stream? - node.js

Question

I'm trying to wrap my head around how you would do this, because you can't just inherit from transform and it doesn't seem like you can just inherit from this particular writeable stream.
Ideally it'd be something like:
const Writeable = require('Writeable');
class Transform extends Writeable {
constructor() {
super();
}
_transform(chunk, encoding) {
}
}
But I can just tell that won't work. The particular writeable stream I'm trying to inherit from would be the tapjs/tap-parser. I'd ideally be able to leverage the event listeners inside of it to parse TAP output.

Answer 1

Hmm, you wrote about Writable, but pasted code for Transform, not sure if you just made a mistake, but if you did this on purpose here is an example for overnighting Transform.
Where line is your data, that you can play with before passing it forward.
let Transform = require("stream").Transform;
class awesome_class_name extends Transform
{
constructor()
{
super()
}
_transform (line, encoding, processed) {
//
// Add the data that came in, to the output stream
//
this.push(line);
//
// We let system know that we finished processing the data.
//
processed();
}
}

Answer 2

I'm not sure about es6 syntax, but here is a traditional Transform stream that receives TAP output and outputs objects describing the various parsed parts:
const Transform = require('stream').Transform;
const inherits = require('util').inherits;
const Parser = require('tap-parser');
function MyTransform() {
const self = this;
this._parser = new Parser();
Transform.call(this, { readableObjectMode: true });
this._parser.on('complete', function(results) {
self.push({ type: 'complete', results });
}).on('assert', function(assert) {
self.push({ type: 'assert', assert });
}).on('comment', function(comment) {
self.push({ type: 'comment', comment });
}).on('plan', function(plan) {
self.push({ type: 'plan', plan });
}).on('version', function(version) {
self.push({ type: 'version', version });
}).on('bailout', function(reason) {
self.push({ type: 'bailout', reason });
}).on('extra', function(extra) {
self.push({ type: 'extra', extra });
});
}
inherits(MyTransform, Transform);
MyTransform.prototype._write = function(chunk, encoding, cb) {
this._parser.write(chunk, cb);
};
MyTransform.prototype._flush = function(cb) {
const self = this;
this._parser.end(function() {
self.push(null);
cb();
});
};