Behaviour for namespace connect mechanism and connect_errors

[Totodore]

I'm implementing a socket.io server in rust and I'm currently adding middlewares to namespaces in order for the user to have authentication.
However I don't know what is the best between these two solutions to handle user provided errors:

• Waiting the end of the user provided handler before connecting the socket/registering the socket to the namespace or sending a connect_error in case of error. The main issue with this solution is that if the user block the task by waiting for something, the socket will only be connected after, so events triggered before the end of the task could be missed.

• Registering the socket immediately after the connect request (before the user provided handler spawn) and eventually disconnect the socket if the handler return an error. This solution implies that a socket could be temporary connected and that a connect packet would be sent and immediately after a connect_error packet.

@darrachequesne do you have an opinion on this question? What solution is used on the official implementation?

[darrachequesne]

Hi!

In the official implementation, we first run all the middlewares and then the socket gets connected (your 1st solution):

socket.io/lib/namespace.ts

Lines 315 to 358 in bf64870

	async _add(
	client: Client<ListenEvents, EmitEvents, ServerSideEvents>,
	auth: Record<string, unknown>,
	fn: (
	socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
	) => void
	) {
	debug("adding socket to nsp %s", this.name);
	const socket = await this._createSocket(client, auth);
	if (
	// @ts-ignore
	this.server.opts.connectionStateRecovery?.skipMiddlewares &&
	socket.recovered &&
	client.conn.readyState === "open"
	) {
	return this._doConnect(socket, fn);
	}
	this.run(socket, (err) => {
	process.nextTick(() => {
	if ("open" !== client.conn.readyState) {
	debug("next called after client was closed - ignoring socket");
	socket._cleanup();
	return;
	}
	if (err) {
	debug("middleware error, sending CONNECT_ERROR packet to the client");
	socket._cleanup();
	if (client.conn.protocol === 3) {
	return socket._error(err.data || err.message);
	} else {
	return socket._error({
	message: err.message,
	data: err.data,
	});
	}
	}
	this._doConnect(socket, fn);
	});
	});
	}

so events triggered before the end of the task could be missed.

Else, a client could receive some data it should not be able to, isn't it?

[Totodore]

Sure, thanks for your quick reply :)