Problem statement

You maintain a legacy file reader utility that processes data in chunks. It uses a callback pattern to push each chunk of data, as shown:

Modern code in your app expects an async iterator that it can loop over using:

You need to write an adapter that makes the legacy callback-based reader compatible with this newer iteration model—without modifying the original code.

Goal

Implement a StreamAdapter class that wraps a legacy reader and exposes an async iterable interface.

The adapter should:

• Use an internal queue to store incoming chunks.

• Resolve iteration as chunks arrive.

• End gracefully when the legacy reader signals completion.

Constraints

• You cannot modify the legacy reader.

• The adapter must implement the [Symbol.asyncIterator]() protocol.

• It must work seamlessly inside for await...of.

• Assume the legacy reader calls the callback with null when the stream ends.

Sample output

The examples below illustrate what the output should look like:

Good luck trying the problem! If you’re unsure how to proceed, check the “Solution” tab above.

Understanding the async iterator protocol

In JavaScript, an object can be used with for await...of if it implements the async iterator protocol. That means your adapter class must define a special method:

This method should return an object with a next() method. Each call to next() must return a promise that resolves to an object shaped like:

In other words, your adapter needs to behave like an asynchronous generator—producing data one chunk at a time as it arrives.

A quick example

Here’s a tiny example of how async iteration works under the hood:

Each call to .next() waits for a value to become available—exactly what your adapter will do with file chunks.

Why this matters

Modern async iteration provides a structured, pull-based way to consume data as it becomes available—without manually managing events or callbacks.

• In traditional streams, the producer “pushes” data through events.

• In async iteration, the consumer “pulls” data when ready by awaiting next().

Your adapter must bridge these two worlds:

• Buffering chunks that arrive early

• Resolving promises as the consumer requests them

This coordination is the heart of the Adapter Pattern in asynchronous systems—aligning two incompatible models (push vs. pull) into one clean, predictable interface.