fix: remove connection manager options (#208)

It's in the libp2p module, no need to make it part of the API here.

Also start components in parallel

Author: achingbrain

packages/libp2p-interfaces/src/components.ts

@@ -124,63 +124,63 @@ export class Components implements Startable {
   }
 
   async beforeStart () {
-    for (const obj of Object.values(this).filter(obj => isStartable(obj))) {
-      const startable = obj as Startable
-
-      if (startable.beforeStart != null) {
-        await startable.beforeStart()
-      }
-    }
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.beforeStart != null) {
+          await startable.beforeStart()
+        }
+      })
+    )
   }
 
   async start () {
-    for (const obj of Object.values(this).filter(obj => isStartable(obj))) {
-      const startable = obj as Startable
-
-      await startable.start()
-    }
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        await startable.start()
+      })
+    )
 
     this.started = true
   }
 
   async afterStart () {
-    for (const obj of Object.values(this).filter(obj => isStartable(obj))) {
-      const startable = obj as Startable
-
-      if (startable.afterStart != null) {
-        await startable.afterStart()
-      }
-    }
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.afterStart != null) {
+          await startable.afterStart()
+        }
+      })
+    )
   }
 
   async beforeStop () {
-    for (const obj of Object.values(this).filter(obj => isStartable(obj))) {
-      const startable = obj as Startable
-
-      if (startable.beforeStop != null) {
-        await startable.beforeStop()
-      }
-    }
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.beforeStop != null) {
+          await startable.beforeStop()
+        }
+      })
+    )
   }
 
   async stop () {
-    for (const obj of Object.values(this).filter(obj => isStartable(obj))) {
-      const startable = obj as Startable
-
-      await startable.stop()
-    }
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        await startable.stop()
+      })
+    )
 
     this.started = false
   }
 
   async afterStop () {
-    for (const obj of Object.values(this).filter(obj => isStartable(obj))) {
-      const startable = obj as Startable
-
-      if (startable.afterStop != null) {
-        await startable.afterStop()
-      }
-    }
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.afterStop != null) {
+          await startable.afterStop()
+        }
+      })
+    )
   }
 
   setPeerId (peerId: PeerId) {

packages/libp2p-interfaces/src/connection-manager/index.ts

@@ -1,61 +1,6 @@
 import type { AbortOptions, EventEmitter } from '../index.js'
 import type { Connection } from '../connection/index.js'
 import type { PeerId } from '../peer-id/index.js'
-import type { AddressSorter } from '../peer-store/index.js'
-import type { Resolver } from '@multiformats/multiaddr'
-
-export interface ConnectionManagerInit {
-  /**
-   * If true, try to connect to all discovered peers up to the connection manager limit
-   */
-  autoDial?: boolean
-
-  /**
-   * The maximum number of connections to keep open
-   */
-  maxConnections: number
-
-  /**
-   * The minimum number of connections to keep open
-   */
-  minConnections: number
-
-  /**
-   * How long to wait between attempting to keep our number of concurrent connections
-   * above minConnections
-   */
-  autoDialInterval: number
-
-  /**
-   * Sort the known addresses of a peer before trying to dial
-   */
-  addressSorter?: AddressSorter
-
-  /**
-   * Number of max concurrent dials
-   */
-  maxParallelDials?: number
-
-  /**
-   * Number of max addresses to dial for a given peer
-   */
-  maxAddrsToDial?: number
-
-  /**
-   * How long a dial attempt is allowed to take
-   */
-  dialTimeout?: number
-
-  /**
-   * Number of max concurrent dials per peer
-   */
-  maxDialsPerPeer?: number
-
-  /**
-   * Multiaddr resolvers to use when dialing
-   */
-  resolvers?: Record<string, Resolver>
-}
 
 export interface ConnectionManagerEvents {
   'peer:connect': CustomEvent<Connection>