Struggling to detect a successful stream connection

[Stono]

What would you like to discuss?

Hi,
I'm really struggling to block until a stream is connected. Taking this pseudo code:

const stream = got.stream(options)

stream.on('data', console.log)
console.log('stream connected') <--- I don't want this to fire _until the stream is connected_

I've tried stream.socket?.on('connect', ...., amongst other permutations and can't for the life of me find a way to detect a successful connection to the remote host.

The other thing i'm thinking about doing is not using .on('data') and instead .on('readable' which seems to fire only once connected.

Any help would really be appreciated as i'm down an epic rabbit hole. Thanks

Checklist

• I have read the documentation.

[Stono]

Another thing i could do is attach to the underlying socket from got.stream.socket however the socket isn't immediately available, eg:

const stream = got.stream()
stream.socket? // undefined until assigned

and I can't see any sort of on('socket' event or similar on the got stream.

[Stono]

In fact there is a got.stream().on('socket', it's just not in the @types definition - would i be building on a side effect here os it OK to use this event?

[Stono]

OK so I've gotten to this point which kinda works, wrapping stream in a promise and await it:

    await new Promise((resolve, reject): void => {
      const stream = got
        .stream(gotOptions)
        .once('close', () => {
          this.logger.debug('socket closed', logArgs)
          stream.socket?.destroy()
        })
        .on('socket', (socket) => {
          socket.on('connect', () => {
            this.logger.debug('socket connected', logArgs)
            resolve(stream)
          })
        })
        .on('error', (err) => {
          this.logger.error('socket error', logArgs)
          reject(err)
        })
    })
    ```

[Stono]

This is where I finally ended up

      const stream = got
        .stream(requestOptions)
        .once('close', () => {
          this.logger.debug('socket closed', logArgs)
          stream.socket?.destroy()
        })
        .on('socket', (socket) => {
          socket.on('connect', () => {
            this.logger.debug('socket connected', logArgs)
          })
        })
        .on('response', (response): void => {
          const rejectWithFailureToParse = (parseError): void => {
            const message = `Request unsuccessful '${response.statusCode}' and could not parse API error response.\n${parseError}`
            reject(Error(message))
          }
          const rejectWithError = (apiErrorResponse): void => {
            reject(Error(apiErrorResponse.message))
          }
          const jsonStream = new JSONStream()
          if (response.statusCode < 200 || response.statusCode > 299) {
            jsonStream.on('data', rejectWithError)
            pipeline(stream, jsonStream, rejectWithFailureToParse)
          } else {
            pipeline(stream, jsonStream, rejectWithFailureToParse)
            resolve(jsonStream)
          }
        })
        .on('error', (err) => {
          if (err.name !== 'TimeoutError') {
            // We dont reject these, they get picked up by the close event anyway
            this.logger.error('socket error', logArgs, err)
            reject(err)
          }
        })
        ```