[@types/node] nodejs stream.Readable new methods (map, filter etc) don't have typescript types yet

[mrbrianevans]

In December 2021-January 2022 there were new methods added to the Nodejs stream.Readable class. (you can see the PR's here: https://github.com/nodejs/node/pulls?q=is%3Apr+is%3Aclosed+author%3Abenjamingr+label%3Astream+%22stream%3A+add+%22). But these do not yet have types in @types/node so they can't be used in typescript projects.

The official documentation can be found here: https://nodejs.org/api/stream.html#readablemapfn-options

The methods are: ( version added indicated next to each one, from docs)

• map (v16.14.0 and v17.4.0)
• filter (v16.14.0 and v17.4.0)
• forEach (v17.5.0)
• toArray (v17.5.0)
• some (v17.5.0)
• find (v17.5.0)
• every (v17.5.0)
• flatMap (v17.5.0)
• drop (v17.5.0)
• take (v17.5.0)
• asIndexedPairs (v17.5.0)
• reduce (v17.5.0)

Example usage (from docs):

import { Readable } from 'node:stream';

await Readable.from([1, 2, 3, 4]).take(2).toArray(); // [1, 2]

Current typescript:

error TS2339: Property 'take' does not exist on type 'Readable'.

3 await Readable.from([1, 2, 3, 4]).take(2).toArray() // [1, 2]
                                    ~~~~


Found 1 error.

And the same error for all the other methods.

I propose that these new methods are added to the types in https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/stream.d.ts#L50

[typescript-bot]

Thanks for the discussion about "node", some useful links for everyone:

• npm
• DT
• Related discussions

Pinging the DT module owners: @microsoft, @DefinitelyTyped, @jkomyno, @alvis, @r3nya, @btoueg, @smac89, @Touffy, @DeividasBakanas, @eyqs, @Hannes-Magnusson-CK, @hoo29, @kjin, @ajafff, @islishude, @mwiktorczyk, @mohsen1, @n-e, @galkin, @parambirs, @eps1lon, @SimonSchick, @ThomasdenH, @WilcoBakker, @wwwy3y3, @samuela, @kuehlein, @bhongy, @chyzwar, @trivikr, @yoursunny, @qwelias, @ExE-Boss, @peterblazejewicz, @addaleax, @victorperin, @ZYSzys, @nodejs, @LinusU, @wafuwafu13, @mcollina.

[mrbrianevans]

For anyone who wants a quick fix, add a file to your project named Readable.d.ts with the following contents, and then you will be able to use the new methods:

import { AbortSignal } from 'abort-controller'

interface SignalOptions{
  signal?: AbortSignal
}
interface ConcurrencyOptions{
  concurrency?: number
}
declare module 'stream' {
  interface Readable {
    map<T>(fn: (data: any, options?: SignalOptions) => T|Promise<T>, options?: SignalOptions & ConcurrencyOptions): Readable
    filter(fn: (data: any, options?: SignalOptions) => boolean|Promise<boolean>, options?: SignalOptions & ConcurrencyOptions): Readable
    forEach(fn: (data: any, options?: SignalOptions) => void|Promise<void>, options?: SignalOptions & ConcurrencyOptions): Promise<void>
    toArray(options?: SignalOptions): Promise<any[]>
    some(fn: (data: any, options?: SignalOptions) => boolean|Promise<boolean>, options?: SignalOptions & ConcurrencyOptions): Promise<boolean>
    find(fn: (data: any, options?: SignalOptions) => boolean|Promise<boolean>, options?: SignalOptions & ConcurrencyOptions): Promise<any|undefined>
    every(fn: (data: any, options?: SignalOptions) => boolean|Promise<boolean>, options?: SignalOptions & ConcurrencyOptions): Promise<boolean>
    flatMap<T>(fn: (data: any, options?: SignalOptions) => T|Promise<T>, options?: SignalOptions & ConcurrencyOptions): Readable
    drop(limit: number, options?: SignalOptions): Readable
    take(limit: number, options?: SignalOptions): Readable
    asIndexedPairs(options?: SignalOptions): Readable
    reduce<T>(fn: (previous:any, data:any, options?: SignalOptions)=>T|Promise<T>, initial?: T, options?: SignalOptions): Promise<T>
  }
}

In writing these, I discovered that Readable is not typed generically.

Readable.from([1,2,3,4]) // type Readable

has the same type as

Readable.from(['a','b','c']) // type Readable

Perhaps this is a seperate issue, but I really think it would be better for these to be typed generically such as Readable<number> or Readable<string> etc, so that the methods described above can return that type. For example:

Readable.from([1,2,3]).toArray() // should have type Promise<number[]>, but atm its just Promise<any[]>

[mrbrianevans]

If these types are acceptable, I can add them in PR to the official types

[mcollina]

Start a PR! We can iterate on them over there.

[mrbrianevans]

@mcollina Okay, opened: #60760

[sapter]

@mrbrianevans do you know why the PR has been closed?

[peterblazejewicz]

@sapter probably technical outcome of removing branch or forked repo. The content of PR can be still fetched by someone else (to rework and resubmit) or just reopen

[himself65]

same error here

[himself65]

TS2339: Property reduce does not exist on type Readable

[ghost]

Which version of @types/node are you using?

[himself65]

latest

[ghost]

v20? Can you provide a minimal reproduction code