github/socket.io
1
1
Fork 0
mirror of https://github.com/socketio/socket.io.git synced 2026-04-30 03:00:39 -04:00
Code Issues Packages Projects Releases Wiki Activity

refactor(eio): use plain IncomingMessage in the public API

Browse Source 
The EngineRequest type was introduced in [1] (engine.io@6.6.0).

[1]: c310b7b6b6

Related: https://github.com/socketio/socket.io/issues/5468
This commit is contained in:
Damien Arrachequesne
2026-04-17 09:52:26 +02:00
parent 4e85378a46
commit b059af6b12
1 changed files with 36 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
packages/engine.io/lib/server.ts
View File

@@ -764,18 +764,20 @@ export class Server extends BaseServer {
/**
* Handles an Engine.IO HTTP request.
*
* @param {EngineRequest} req
* @param {IncomingMessage} req
* @param {ServerResponse} res
*/
public handleRequest(req: EngineRequest, res: ServerResponse) {
public handleRequest(req: IncomingMessage, res: ServerResponse) {
debug('handling "%s" http request "%s"', req.method, req.url);
this.prepare(req);
req.res = res;
const engineRequest = req as EngineRequest;
this.prepare(engineRequest);
engineRequest.res = res;
const callback: ErrorCallback = (errorCode, errorContext) => {
if (errorCode !== undefined) {
this.emit("connection_error", {
req,
req: engineRequest,
code: errorCode,
message: Server.errorMessages[errorCode],
context: errorContext,
@@ -784,25 +786,27 @@ export class Server extends BaseServer {
return;
}
if (req._query.sid) {
if (engineRequest._query.sid) {
debug("setting new request for existing client");
this.clients[req._query.sid].transport.onRequest(req);
this.clients[engineRequest._query.sid].transport.onRequest(
engineRequest,
);
} else {
const closeConnection = (errorCode, errorContext) =>
abortRequest(res, errorCode, errorContext);
this.handshake(
req._query.transport as TransportName,
req,
engineRequest._query.transport as TransportName,
engineRequest,
closeConnection,
);
}
};
this._applyMiddlewares(req, res, (err) => {
this._applyMiddlewares(engineRequest, res, (err) => {
if (err) {
callback(Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
} else {
this.verify(req, false, callback);
this.verify(engineRequest, false, callback);
}
});
}
@@ -811,17 +815,19 @@ export class Server extends BaseServer {
* Handles an Engine.IO HTTP Upgrade.
*/
public handleUpgrade(
req: EngineRequest,
req: IncomingMessage,
socket: Duplex,
upgradeHead: Buffer,
) {
this.prepare(req);
const engineRequest = req as EngineRequest;
const res = new WebSocketResponse(req, socket);
this.prepare(engineRequest);
const res = new WebSocketResponse(engineRequest, socket);
const callback: ErrorCallback = (errorCode, errorContext) => {
if (errorCode !== undefined) {
this.emit("connection_error", {
req,
req: engineRequest,
code: errorCode,
message: Server.errorMessages[errorCode],
context: errorContext,
@@ -838,18 +844,22 @@ export class Server extends BaseServer {
res.writeHead();
// delegate to ws
this.ws.handleUpgrade(req, socket, head, (websocket) => {
this.onWebSocket(req, socket, websocket);
this.ws.handleUpgrade(engineRequest, socket, head, (websocket) => {
this.onWebSocket(engineRequest, socket, websocket);
});
};
this._applyMiddlewares(req, res as unknown as ServerResponse, (err) => {
if (err) {
callback(Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
} else {
this.verify(req, true, callback);
}
});
this._applyMiddlewares(
engineRequest,
res as unknown as ServerResponse,
(err) => {
if (err) {
callback(Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
} else {
this.verify(engineRequest, true, callback);
}
},
);
}
/**
@@ -947,7 +957,7 @@ export class Server extends BaseServer {
server.on("request", (req, res) => {
if (check(req)) {
debug('intercepting request for path "%s"', path);
this.handleRequest(req as EngineRequest, res);
this.handleRequest(req, res);
} else {
let i = 0;
const l = listeners.length;
@@ -960,7 +970,7 @@ export class Server extends BaseServer {
if (~this.opts.transports.indexOf("websocket")) {
server.on("upgrade", (req, socket, head) => {
if (check(req)) {
this.handleUpgrade(req as EngineRequest, socket, head);
this.handleUpgrade(req, socket, head);
} else if (false !== options.destroyUpgrade) {
// default node behavior is to disconnect when no handlers
// but by adding a handler, we prevent that