feat!: merge stat properties into stream/connection objects

Moves `direction`, `timeline`, `status`, etc from `.stat` objects
on `Stream` and `Connection` objects onto the root object so we
don't have awkward constructs like `conn.stat.status`, instead the
simpler `conn.status`.

Fixes #1849

BREAKING CHANGE: `stream.stat.*` and `conn.stat.*` properties are now accessed via `stream.*` and `conn.*`

Author: achingbrain

.github/workflows/interop-test.yml

@@ -12,11 +12,6 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - uses: ipfs/aegir/actions/cache-node-modules@master
-        with:
-          directories: |
-            ./interop/node_modules
-      - name: Build interop
-        run: (cd interop && npm i && npm run build)
       - name: Build images
         run: (cd interop && make)
       - name: Save package-lock.json as artifact

examples/protocol-and-stream-muxing/README.md

@@ -82,7 +82,7 @@ There is still one last feature, you can provide multiple protocols for the same
 
 ```JavaScript
 node2.handle(['/another-protocol/1.0.0', '/another-protocol/2.0.0'], ({ stream }) => {
-  if (stream.stat.protocol === '/another-protocol/2.0.0') {
+  if (stream.protocol === '/another-protocol/2.0.0') {
     // handle backwards compatibility
   }
 
@@ -136,7 +136,7 @@ node2.handle(['/a', '/b'], ({ stream }) => {
     stream,
     async function (source) {
       for await (const msg of source) {
-        console.log(`from: ${stream.stat.protocol}, msg: ${uint8ArrayToString(msg.subarray())}`)
+        console.log(`from: ${stream.protocol}, msg: ${uint8ArrayToString(msg.subarray())}`)
       }
     }
   )

interop/BrowserDockerfile

@@ -8,4 +8,4 @@ RUN ./node_modules/.bin/playwright install
 ARG BROWSER=chromium # Options: chromium, firefox, webkit
 ENV BROWSER=$BROWSER
 
-ENTRYPOINT npm test -- --build false --types false -t browser -- --browser $BROWSER
+ENTRYPOINT npm run test:interop:multidim -- --build false --types false -t browser -- --browser $BROWSER

interop/Dockerfile

@@ -4,12 +4,8 @@ WORKDIR /app
 COPY package.json .
 COPY ./node_modules ./node_modules
 COPY ./packages ./packages
+COPY ./interop ./interop
 
 WORKDIR /app/interop
-COPY ./interop/node_modules ./node_modules
-COPY ./interop/dist ./dist
-COPY ./interop/package.json .
-COPY ./interop/.aegir.js .
-COPY ./interop/relay.js .
 
-ENTRYPOINT [ "npm", "test", "--", "--build", "false", "--types", "false", "-t", "node" ]
+ENTRYPOINT [ "npm", "run", "test:interop:multidim", "--", "--build", "false", "--types", "false", "-t", "node" ]

interop/package.json

@@ -10,19 +10,19 @@
   "scripts": {
     "start": "node index.js",
     "build": "aegir build",
-    "test": "aegir test"
+    "test:interop:multidim": "aegir test"
   },
   "dependencies": {
     "@chainsafe/libp2p-noise": "^12.0.0",
     "@chainsafe/libp2p-yamux": "^4.0.1",
-    "@libp2p/mplex": "^8.0.1",
-    "@libp2p/tcp": "^7.0.1",
-    "@libp2p/webrtc": "^2.0.7",
-    "@libp2p/websockets": "^6.0.1",
-    "@libp2p/webtransport": "^2.0.1",
+    "@libp2p/mplex": "^8.0.0",
+    "@libp2p/tcp": "^7.0.0",
+    "@libp2p/webrtc": "^2.0.0",
+    "@libp2p/websockets": "^6.0.0",
+    "@libp2p/webtransport": "^2.0.0",
     "@multiformats/mafmt": "^12.1.2",
     "@multiformats/multiaddr": "^12.1.3",
-    "libp2p": "../packages/libp2p",
+    "libp2p": "^0.45.0",
     "redis": "4.5.1"
   },
   "browser": {

package.json

@@ -45,6 +45,7 @@
     ]
   },
   "workspaces": [
-    "packages/*"
+    "packages/*",
+    "interop"
   ]
 }

packages/interface-compliance-tests/src/connection/index.ts

@@ -22,21 +22,19 @@ export default (test: TestSetup<Connection>): void => {
         expect(connection.id).to.exist()
         expect(connection.remotePeer).to.exist()
         expect(connection.remoteAddr).to.exist()
-        expect(connection.stat.status).to.equal('OPEN')
-        expect(connection.stat.timeline.open).to.exist()
-        expect(connection.stat.timeline.close).to.not.exist()
-        expect(connection.stat.direction).to.exist()
+        expect(connection.status).to.equal('OPEN')
+        expect(connection.timeline.open).to.exist()
+        expect(connection.timeline.close).to.not.exist()
+        expect(connection.direction).to.exist()
         expect(connection.streams).to.eql([])
         expect(connection.tags).to.eql([])
       })
 
       it('should get the metadata of an open connection', () => {
-        const stat = connection.stat
-
-        expect(stat.status).to.equal('OPEN')
-        expect(stat.direction).to.exist()
-        expect(stat.timeline.open).to.exist()
-        expect(stat.timeline.close).to.not.exist()
+        expect(connection.status).to.equal('OPEN')
+        expect(connection.direction).to.exist()
+        expect(connection.timeline.open).to.exist()
+        expect(connection.timeline.close).to.not.exist()
       })
 
       it('should return an empty array of streams', () => {
@@ -51,7 +49,7 @@ export default (test: TestSetup<Connection>): void => {
         const protocolToUse = '/echo/0.0.1'
         const stream = await connection.newStream([protocolToUse])
 
-        expect(stream).to.have.nested.property('stat.protocol', protocolToUse)
+        expect(stream).to.have.property('protocol', protocolToUse)
 
         const connStreams = connection.streams
 
@@ -79,19 +77,19 @@ export default (test: TestSetup<Connection>): void => {
         }, proxyHandler)
 
         connection = await test.setup()
-        connection.stat.timeline = timelineProxy
+        connection.timeline = timelineProxy
       })
 
       afterEach(async () => {
         await test.teardown()
       })
 
       it('should be able to close the connection after being created', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         await connection.close()
 
-        expect(connection.stat.timeline.close).to.exist()
-        expect(connection.stat.status).to.equal('CLOSED')
+        expect(connection.timeline.close).to.exist()
+        expect(connection.status).to.equal('CLOSED')
       })
 
       it('should be able to close the connection after opening a stream', async () => {
@@ -100,18 +98,18 @@ export default (test: TestSetup<Connection>): void => {
         await connection.newStream([protocol])
 
         // Close connection
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         await connection.close()
 
-        expect(connection.stat.timeline.close).to.exist()
-        expect(connection.stat.status).to.equal('CLOSED')
+        expect(connection.timeline.close).to.exist()
+        expect(connection.status).to.equal('CLOSED')
       })
 
       it('should properly track streams', async () => {
         // Open stream
         const protocol = '/echo/0.0.1'
         const stream = await connection.newStream([protocol])
-        expect(stream).to.have.nested.property('stat.protocol', protocol)
+        expect(stream).to.have.property('protocol', protocol)
 
         // Close stream
         stream.close()
@@ -123,7 +121,7 @@ export default (test: TestSetup<Connection>): void => {
         // Open stream
         const protocol = '/echo/0.0.1'
         const stream = await connection.newStream(protocol)
-        expect(stream).to.have.nested.property('stat.direction', 'outbound')
+        expect(stream).to.have.property('direction', 'outbound')
       })
 
       it.skip('should track inbound streams', async () => {
@@ -135,20 +133,20 @@ export default (test: TestSetup<Connection>): void => {
 
       it('should support a proxy on the timeline', async () => {
         sinon.spy(proxyHandler, 'set')
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
 
         await connection.close()
         // @ts-expect-error - fails to infer callCount
         expect(proxyHandler.set.callCount).to.equal(1)
         // @ts-expect-error - fails to infer getCall
         const [obj, key, value] = proxyHandler.set.getCall(0).args
-        expect(obj).to.eql(connection.stat.timeline)
+        expect(obj).to.eql(connection.timeline)
         expect(key).to.equal('close')
-        expect(value).to.be.a('number').that.equals(connection.stat.timeline.close)
+        expect(value).to.be.a('number').that.equals(connection.timeline.close)
       })
 
       it('should fail to create a new stream if the connection is closing', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         const p = connection.close()
 
         try {
@@ -165,7 +163,7 @@ export default (test: TestSetup<Connection>): void => {
       })
 
       it('should fail to create a new stream if the connection is closed', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         await connection.close()
 
         try {

packages/interface-compliance-tests/src/mocks/connection.ts

@@ -9,7 +9,8 @@ import { mockMultiaddrConnection } from './multiaddr-connection.js'
 import { mockMuxer } from './muxer.js'
 import { mockRegistrar } from './registrar.js'
 import type { AbortOptions } from '@libp2p/interface'
-import type { MultiaddrConnection, Connection, Stream, ConnectionStat, Direction } from '@libp2p/interface/connection'
+import type { MultiaddrConnection, Connection, Stream, Direction, ConnectionTimeline } from '@libp2p/interface/connection'
+import type * as Status from '@libp2p/interface/connection/status'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
 import type { Registrar } from '@libp2p/interface-internal/registrar'
@@ -38,7 +39,10 @@ class MockConnection implements Connection {
   public remoteAddr: Multiaddr
   public remotePeer: PeerId
   public direction: Direction
-  public stat: ConnectionStat
+  public timeline: ConnectionTimeline
+  public multiplexer?: string
+  public encryption?: string
+  public status: keyof typeof Status
   public streams: Stream[]
   public tags: string[]
 
@@ -52,13 +56,11 @@ class MockConnection implements Connection {
     this.remoteAddr = remoteAddr
     this.remotePeer = remotePeer
     this.direction = direction
-    this.stat = {
-      status: STATUS.OPEN,
-      direction,
-      timeline: maConn.timeline,
-      multiplexer: 'test-multiplexer',
-      encryption: 'yes-yes-very-secure'
-    }
+    this.status = STATUS.OPEN
+    this.direction = direction
+    this.timeline = maConn.timeline
+    this.multiplexer = 'test-multiplexer'
+    this.encryption = 'yes-yes-very-secure'
     this.streams = []
     this.tags = []
     this.muxer = muxer
@@ -74,7 +76,7 @@ class MockConnection implements Connection {
       throw new Error('protocols must have a length')
     }
 
-    if (this.stat.status !== STATUS.OPEN) {
+    if (this.status !== STATUS.OPEN) {
       throw new CodeError('connection must be open to create streams', 'ERR_CONNECTION_CLOSED')
     }
 
@@ -85,11 +87,8 @@ class MockConnection implements Connection {
     const streamWithProtocol: Stream = {
       ...stream,
       ...result.stream,
-      stat: {
-        ...stream.stat,
-        direction: 'outbound',
-        protocol: result.protocol
-      }
+      direction: 'outbound',
+      protocol: result.protocol
     }
 
     this.streams.push(streamWithProtocol)
@@ -106,13 +105,13 @@ class MockConnection implements Connection {
   }
 
   async close (): Promise<void> {
-    this.stat.status = STATUS.CLOSING
+    this.status = STATUS.CLOSING
     await this.maConn.close()
     this.streams.forEach(s => {
       s.close()
     })
-    this.stat.status = STATUS.CLOSED
-    this.stat.timeline.close = Date.now()
+    this.status = STATUS.CLOSED
+    this.timeline.close = Date.now()
   }
 }
 
@@ -137,7 +136,7 @@ export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectio
           .then(({ stream, protocol }) => {
             log('%s: incoming stream opened on %s', direction, protocol)
             muxedStream = { ...muxedStream, ...stream }
-            muxedStream.stat.protocol = protocol
+            muxedStream.protocol = protocol
 
             connection.addStream(muxedStream)
             const { handler } = registrar.getHandler(protocol)
@@ -178,12 +177,10 @@ export function mockStream (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Sourc
     closeWrite: () => {},
     abort: () => {},
     reset: () => {},
-    stat: {
-      direction: 'outbound',
-      protocol: '/foo/1.0.0',
-      timeline: {
-        open: Date.now()
-      }
+    direction: 'outbound',
+    protocol: '/foo/1.0.0',
+    timeline: {
+      open: Date.now()
     },
     metadata: {},
     id: `stream-${Date.now()}`

packages/interface-compliance-tests/src/mocks/muxer.ts

@@ -87,7 +87,7 @@ class MuxedStream {
       }
 
       if (this.sinkEnded) {
-        this.stream.stat.timeline.close = Date.now()
+        this.stream.timeline.close = Date.now()
 
         if (onEnd != null) {
           onEnd(endErr)
@@ -109,7 +109,7 @@ class MuxedStream {
       }
 
       if (this.sourceEnded) {
-        this.stream.stat.timeline.close = Date.now()
+        this.stream.timeline.close = Date.now()
 
         if (onEnd != null) {
           onEnd(endErr)
@@ -251,11 +251,9 @@ class MuxedStream {
         this.input.end(err)
         onSinkEnd(err)
       },
-      stat: {
-        direction: type === 'initiator' ? 'outbound' : 'inbound',
-        timeline: {
-          open: Date.now()
-        }
+      direction: type === 'initiator' ? 'outbound' : 'inbound',
+      timeline: {
+        open: Date.now()
       },
       metadata: {}
     }

packages/interface-compliance-tests/src/stream-muxer/base-test.ts

@@ -44,12 +44,12 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
 
       const conn = await dialer.newStream()
       expect(dialer.streams).to.include(conn)
-      expect(isValidTick(conn.stat.timeline.open)).to.equal(true)
+      expect(isValidTick(conn.timeline.open)).to.equal(true)
 
       void drainAndClose(conn)
 
       const stream = await onStreamPromise.promise
-      expect(isValidTick(stream.stat.timeline.open)).to.equal(true)
+      expect(isValidTick(stream.timeline.open)).to.equal(true)
       // Make sure the stream is being tracked
       expect(listener.streams).to.include(stream)
 
@@ -59,12 +59,12 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       const endedStream = await onStreamEndPromise.promise
       expect(listener.streams).to.not.include(endedStream)
 
-      if (endedStream.stat.timeline.close == null) {
+      if (endedStream.timeline.close == null) {
         throw new Error('timeline had no close time')
       }
 
       // Make sure the stream is removed from tracking
-      expect(isValidTick(endedStream.stat.timeline.close)).to.equal(true)
+      expect(isValidTick(endedStream.timeline.close)).to.equal(true)
 
       await drainAndClose(dialer)
       await drainAndClose(listener)
@@ -96,9 +96,9 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       void drainAndClose(conn)
 
       const stream = await onStreamPromise.promise
-      expect(isValidTick(stream.stat.timeline.open)).to.equal(true)
+      expect(isValidTick(stream.timeline.open)).to.equal(true)
       expect(listener.streams).to.include(conn)
-      expect(isValidTick(conn.stat.timeline.open)).to.equal(true)
+      expect(isValidTick(conn.timeline.open)).to.equal(true)
       void drainAndClose(stream)
 
       await drainAndClose(dialer)