libp2p 2.10.0-da78fa851 → 2.10.0-e8398d97e

package/src/connection.ts

@@ -6,7 +6,7 @@ import { CONNECTION_CLOSE_TIMEOUT, PROTOCOL_NEGOTIATION_TIMEOUT } from './connec
 import { isDirect } from './connection-manager/utils.ts'
 import { MuxerUnavailableError } from './errors.ts'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.ts'
-import type { AbortOptions, Logger, MessageStreamDirection, Connection as ConnectionInterface, Stream, NewStreamOptions, PeerId, ConnectionLimits, StreamMuxer, Metrics, PeerStore, MultiaddrConnection, MessageStreamEvents, MultiaddrConnectionTimeline, ConnectionStatus, MessageStream } from '@libp2p/interface'
+import type { AbortOptions, Logger, MessageStreamDirection, Connection as ConnectionInterface, Stream, NewStreamOptions, PeerId, ConnectionLimits, StreamMuxer, Metrics, PeerStore, MultiaddrConnection, MessageStreamEvents, MultiaddrConnectionTimeline, ConnectionStatus, MessageStream, StreamMiddleware } from '@libp2p/interface'
 import type { Registrar } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -126,7 +126,7 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
     }
 
     this.log.trace('starting new stream for protocols %s', protocols)
-    let muxedStream = await this.muxer.createStream({
+    const muxedStream = await this.muxer.createStream({
       ...options,
 
       // most underlying transports only support negotiating a single protocol
@@ -179,23 +179,7 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
 
       const middleware = this.components.registrar.getMiddleware(muxedStream.protocol)
 
-      middleware.push((stream, connection, next) => {
-        next(stream, connection)
-      })
-
-      let i = 0
-      let connection: ConnectionInterface = this
-
-      while (i < middleware.length) {
-        // eslint-disable-next-line no-loop-func
-        middleware[i](muxedStream, connection, (s, c) => {
-          muxedStream = s
-          connection = c
-          i++
-        })
-      }
-
-      return muxedStream
+      return await this.runMiddlewareChain(muxedStream, this, middleware)
     } catch (err: any) {
       if (muxedStream.status === 'open') {
         muxedStream.abort(err)
@@ -208,7 +192,7 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
   }
 
   private async onIncomingStream (evt: CustomEvent<Stream>): Promise<void> {
-    let muxedStream = evt.detail
+    const muxedStream = evt.detail
 
     const signal = AbortSignal.timeout(this.inboundStreamProtocolNegotiationTimeout)
     setMaxListeners(Infinity, signal)
@@ -260,20 +244,40 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
         next(stream, connection)
       })
 
-      let connection: ConnectionInterface = this
-
-      for (const m of middleware) {
-        // eslint-disable-next-line no-loop-func
-        await m(muxedStream, connection, (s, c) => {
-          muxedStream = s
-          connection = c
-        })
-      }
+      await this.runMiddlewareChain(muxedStream, this, middleware)
     } catch (err: any) {
       muxedStream.abort(err)
     }
   }
 
+  private async runMiddlewareChain (stream: Stream, connection: ConnectionInterface, middleware: StreamMiddleware[]): Promise<Stream> {
+    for (let i = 0; i < middleware.length; i++) {
+      const mw = middleware[i]
+      stream.log.trace('running middleware', i, mw)
+
+      // eslint-disable-next-line no-loop-func
+      await new Promise<void>((resolve, reject) => {
+        try {
+          const result = mw(stream, connection, (s, c) => {
+            stream = s
+            connection = c
+            resolve()
+          })
+
+          if (result instanceof Promise) {
+            result.catch(reject)
+          }
+        } catch (err) {
+          reject(err)
+        }
+      })
+
+      stream.log.trace('ran middleware', i, mw)
+    }
+
+    return stream
+  }
+
   /**
    * Close the connection
    */

package/src/libp2p.ts

@@ -119,8 +119,8 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       connectionEncrypters: (init.connectionEncrypters ?? []).map((fn, index) => this.configureComponent(`connection-encryption-${index}`, fn(this.components))),
       streamMuxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
       inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout,
-      inboundStreamProtocolNegotiationTimeout: init.connectionManager?.inboundStreamProtocolNegotiationTimeout ?? init.connectionManager?.protocolNegotiationTimeout,
-      outboundStreamProtocolNegotiationTimeout: init.connectionManager?.outboundStreamProtocolNegotiationTimeout ?? init.connectionManager?.protocolNegotiationTimeout,
+      inboundStreamProtocolNegotiationTimeout: init.connectionManager?.inboundStreamProtocolNegotiationTimeout,
+      outboundStreamProtocolNegotiationTimeout: init.connectionManager?.outboundStreamProtocolNegotiationTimeout,
       connectionCloseTimeout: init.connectionManager?.connectionCloseTimeout
     })
 

package/src/registrar.ts

@@ -1,5 +1,5 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { mergeOptions, trackedMap } from '@libp2p/utils'
+import { trackedMap } from '@libp2p/utils'
 import { DuplicateProtocolHandlerError, UnhandledProtocolError } from './errors.js'
 import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions, AbortOptions, Metrics, StreamMiddleware } from '@libp2p/interface'
 import type { Registrar as RegistrarInterface } from '@libp2p/interface-internal'
@@ -95,14 +95,13 @@ export class Registrar implements RegistrarInterface {
       throw new DuplicateProtocolHandlerError(`Handler already registered for protocol ${protocol}`)
     }
 
-    const options = mergeOptions.bind({ ignoreUndefined: true })({
-      maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
-      maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS
-    }, opts)
-
     this.handlers.set(protocol, {
       handler,
-      options
+      options: {
+        maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
+        maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS,
+        ...opts
+      }
     })
 
     // Add new protocol to self protocols in the peer store

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.10.0-da78fa851'
+export const version = '2.10.0-e8398d97e'
 export const name = 'js-libp2p'