The proper way of implementing stream wrapper?

[Antonius-S]

Hi all, I want to create "wrapper" (proxy, re-translator) of a Readable stream that would be Readable stream as well. Something like IncomingMessage that wraps Socket. I want it to have some data processing but for the beginning this is just a 1:1 copier. I also want the wrapper to be as slim as possible - just to do what I need with minimal code. So I'm not asking how to do this but how to do this in proper, recommended way.
I'm on Node 12.
That's what I came to so far:

class ReadableWrapper extends stream.Readable
{
  /**
    @param {stream.ReadableOptions} options - options for call to Readable
    @param {stream.Readable} stm - source stream
   */
  constructor(options, stm)
  {
    // Fix for Node < 14 bug with wrong autoDestroy init
    if (options && options.autoDestroy === undefined)
      options.autoDestroy = true;
    super(options);
    this._stream = stm;
    this._stream.on('readable', this._stream_onReadable.bind(this));
  }

  // Listener of underlying stream's 'readable' event - get data and push it to self
  _stream_onReadable()
  {
    const buf = this._stream.read(this._stream.readableLength);
    // ... do stuff with buf ...
    this.push(buf);
  }

  // No code needed here
  _read(size)
  {
  }

  // Close underlying stream on destroy
  _destroy(error, callback)
  {
    if (this._stream)
      this._stream.close((err) => callback(err || error));
    else
      callback(error);
  }
}

And the usage is like

const rd = new ReadableWrapper({}, fs.createReadStream('somebigfile.bin'));
rd.on('data', (data) => console.log(data.length));

The reason I can't do reading in 'ReadableWrapper._read' is that source stream could be not ready at the time the method is called so its 'read' will return null thus finishing the wrapper stream. And though docs say

When [readable._read()] is called, if data is available from the resource, the implementation should begin pushing that data into the read queue using the [this.push(dataChunk)] method

they say nothing what to do if data is not available from the resource
I also want the class to handle both flowing and paused mode so I can't use 'data' event.

So the questions:

• Is my implementation correct?
• Or should I explicitly pause the wrapper and start it when underlying stream emits 'readable'? But this will create a mess if user wants the wrapper in flowing mode.
• Or should I reschedule next 'ReadableWrapper._read' call?
• Currently this implementation won't call 'ReadableWrapper._destroy' options.autoDestroy was false but I think I need to close the source stream regardless of this condition. What's the best way of doing this - catch ReadableWrapper's 'end' event or maybe close it when source stream's '.read' method called from 'readable' listener returns null?