fix: allow reconnecting with the same peer id

This handles the case when one of the peers was disconnected without others knowing it,
ex. iframe was reloaded from the inside.
If another party continues to listen -> it will accept the handshakes with the same id by default.

one.listen('two');
two.connect('one');
two.connect('one'); <-- this will re-establish connection

Author: maxokorokov

packages/core/src/peer.spec.ts

@@ -2007,6 +2007,171 @@ describe('Peer', () => {
 		]);
 	});
 
+	test(`should disconnect exising when reconnecting with the same id`, () => {
+		const [one, two, oldThree] = createPeerTree();
+		clearMessages();
+
+		// 1-2, 1-3
+		// simulating reconnection 1-3, different peer instance, same id
+		const newThree = createPeer('three');
+		newThree.connect('one');
+
+		// should have received 'disconnect' message and become detached
+		expect(oldThree.peerConnections).toEqual(new Map());
+		expect(oldThree.knownPeers).toEqual(new Map([['three', knownMessages]]));
+
+		// network should stay the same
+		expect(one.peerConnections).toEqual(
+			new Map([
+				['two', new Set(['two'])],
+				['three', new Set(['three'])],
+			]),
+		);
+		expect(two.peerConnections).toEqual(new Map([['one', new Set(['one', 'three'])]]));
+		expect(newThree.peerConnections).toEqual(new Map([['one', new Set(['one', 'two'])]]));
+
+		// network should stay the same
+		for (const peer of [one, two, newThree]) {
+			expect(peer.knownPeers).toEqual(
+				new Map([
+					['one', knownMessages],
+					['two', knownMessages],
+					['three', knownMessages],
+				]),
+			);
+		}
+
+		expectMessages(onMessage, [
+			// on 3.connect(1) existing 'three' should get disconnected
+			{
+				three: {
+					from: 'one',
+					to: [],
+					payload: {
+						type: 'disconnect',
+						version: '1.0',
+						disconnected: 'one',
+						unreachable: ['one', 'two'],
+					},
+				},
+			},
+			{
+				two: {
+					from: 'one',
+					to: [],
+					payload: {
+						type: 'disconnect',
+						version: '1.0',
+						disconnected: 'three',
+						unreachable: ['three'],
+					},
+				},
+			},
+			// Handle handshake as in normal connection:
+			// 3 -> 1 handshake
+			// 1 -> 2 connect(3)
+			// 1 -> 3 handshake
+			// 3 -> 1 connect(3)
+			// 1 -> 3 connect(1,2)
+			{
+				one: {
+					from: 'three',
+					to: ['one'],
+					payload: {
+						type: 'handshake',
+						endpointId: 'one',
+						remoteId: 'three',
+						version: '1.0',
+						knownPeers: new Map([['three', [{ type: 'known', version: '1.0' }]]]),
+					},
+				},
+			},
+			{
+				two: {
+					from: 'one',
+					to: [],
+					payload: {
+						type: 'connect',
+						version: '1.0',
+						knownPeers: new Map([['three', [{ type: 'known', version: '1.0' }]]]),
+						connected: ['three'],
+					},
+				},
+			},
+			{
+				three: {
+					from: 'one',
+					to: ['three'],
+					payload: {
+						type: 'handshake',
+						endpointId: 'three',
+						remoteId: 'one',
+						version: '1.0',
+						knownPeers: new Map([
+							['one', [{ type: 'known', version: '1.0' }]],
+							['two', [{ type: 'known', version: '1.0' }]],
+						]),
+					},
+				},
+			},
+			{
+				one: {
+					from: 'three',
+					to: ['one'],
+					payload: {
+						type: 'connect',
+						version: '1.0',
+						knownPeers: new Map([['three', [{ type: 'known', version: '1.0' }]]]),
+						connected: ['three'],
+					},
+				},
+			},
+			{
+				three: {
+					from: 'one',
+					to: ['three'],
+					payload: {
+						type: 'connect',
+						version: '1.0',
+						knownPeers: new Map([
+							['one', [{ type: 'known', version: '1.0' }]],
+							['two', [{ type: 'known', version: '1.0' }]],
+						]),
+						connected: ['one', 'two'],
+					},
+				},
+			},
+		]);
+		expectErrors(onError, []);
+	});
+
+	test(`should not disconnect exising when reconnecting with the same id and using filter`, () => {
+		const one = createPeer('one');
+		const two = createPeer('two');
+
+		// 1-2
+		one.listen(({ from }) => !one.knownPeers.has(from));
+		two.connect('one');
+
+		for (const peer of [one, two]) {
+			expect(peer.knownPeers).toEqual(
+				new Map([
+					['one', knownMessages],
+					['two', knownMessages],
+				]),
+			);
+		}
+
+		clearMessages();
+
+		// simulating reconnection 1-2, different peer instance, same id
+		const newTwo = createPeer('two');
+		newTwo.connect('one');
+
+		// no messages should be sent, handshake should be blocked by filter
+		expectMessages(onMessage, []);
+	});
+
 	test(`should register new messages`, () => {
 		const one = createPeer('one', { knownMessages: [] });
 		const two = createPeer('two', { knownMessages: [] });

packages/core/src/peer.ts

@@ -461,14 +461,7 @@ export class MessagePeer<M extends Message> implements MessagePeerType<M> {
 		const { remoteId } = payload;
 
 		// -> (structure ok; 'handshake' for us)
-		// 1. Do we already have a connection to this peer?
-		if (this.#endpoints.has(remoteId)) {
-			logger(`PEER(${this.id}): HS declined: already connected to '${remoteId}'`);
-			return;
-		}
-
-		// -> (structure ok; 'handshake' for us; no existing; accepting)
-		// 2. Does the peer match our filters?
+		// 1. Does the peer match our filters?
 		if (!eventMatchesFilters(event, this.#connectionFilters)) {
 			logger(
 				`PEER(${this.id}): HS declined: connection from '${remoteId}' does not match any of the filters:`,
@@ -477,7 +470,15 @@ export class MessagePeer<M extends Message> implements MessagePeerType<M> {
 			return;
 		}
 
-		// -> (structure ok; 'handshake' for us; no existing; accepting; matches filters)
+		// -> (structure ok; 'handshake' for us; matches filters)
+		// 2. Do we already have a connection to this peer?
+		const exisingEndpoint = this.#endpoints.get(remoteId);
+		if (exisingEndpoint) {
+			logger(`PEER(${this.id}): already connected to '${remoteId}' -> disconnecting`);
+			this.#disconnectEndpoint(exisingEndpoint);
+		}
+
+		// -> (structure ok; 'handshake' for us; matches filters; handled exising)
 		// 3. Create a new endpoint for the peer, configure, and register it
 		const [port] = ports;