Accessing a writable stream for `context.response`

Firstly, thanks for your effort so far in creating oak!

I’m trying trying to implement a proxy that writes data from a readable stream to the response of an incoming request in a granular fashion using streams.

In express I would do something like this (if I wanted to manipulate the chunks in some way):

readableStream
    .on('data', chunk => {
        response.write(chunk);
    })
    .on('end', () => {
        response.status(statusCode);
        response.end();
    });

Or just:

readableStream.pipe(writableStream);

Unfortunately I’m stuck right now as I can’t find anyway to access an underlying WriteableStream interface for the response.

Is this possible?

[patrickkunka]

FYI for anyone else that needs to convert from a whatwg ReadableStreamDefaultReader to Deno.Reader while maintaining Uint8Array throughput, this is the util I ended up creating:

https://deno.land/x/bandwidth_throttle_stream@1.1.0/Util/readerToDenoReader.ts

[patrickkunka]

Thanks a lot both. I was a bit confused by the fact that the response body could take a Reader but not a Writer, but now I see this is fundamental to the design goals of Deno. Just required a bit of a shift in thinking.

The below is what I ended up with and its working nicely.

Firstly, my proxy uses fetch to proxy the incoming request to another server, and the goal is then that I can stream chunks from the fetch response directly back to the server response while manipulating throughput on the fly.

//  `body` provides access to a `ReadableStream` instance for the fetch request

const {body} = await fetch(url);

// That stream can then be transformed as necessary with `.pipeThrough()`,
// and finally turned into a `reader` using `.getReader()`:

const reader = body
    .pipeThrough<Uint8Array>(myCustomTransformStreamHere))
    .getReader();

// However, the `reader` is an instance of the standard `ReadableStreamDefaultReader`,
// and not `Deno.Reader`, so some final conversion is needed between the two:

const denoReader: Deno.Reader =  {
    read: async (p) => {
        const {value} = await reader.read();

        if (!value) return null;

        p.set(value);

        return value.length;
    }
};

context.response.body = denoReader;

The final conversion between reader types is just a crude MVP for now. There is an important edge case that needs to be covered where value.length is greater than p.length, and a queue would need to be implemented, but the basic approach is working nicely.

Thanks for your help.