FeathersJS Service Hooks and Transport Layer Cancellation: Propagating Socket.io Disconnect to Ongoing DB Query

Answer

Yes – a Socket.io client disconnect can be turned into an AbortSignal that FeathersJS hooks can read, without any change to the client. The signal is injected into hook.params by the Socket.io provider, and a service method can honour it by wrapping the database call in a cancellation‑aware pattern. After detecting abort, clean up any acquired resources in a finally block (or via the driver’s release/cancel method).

Confirmed facts

• FeathersJS providers (including the Socket.io provider) are allowed to augment hook.params before invoking a service method.
• The Socket.io provider receives a disconnect event for each connected socket; from that event you can create an AbortController and store its signal in hook.params.signal.
• When the driver lacks native AbortSignal support, a common pattern is to race the query promise against a promise that rejects when signal.aborted becomes true, or to poll signal.aborted inside a custom query wrapper and throw an error to abort.
• Resources such as pooled connections, transactions, or streams must be released in a finally block (or via the driver’s release/cancel method) to avoid leaks when an abort error is thrown.

Likely explanation / steps for this case

1. Configure the Socket.io provider (usually in src/socket.io.js):

   const { AbortController } = require('abort-controller');
   module.exports = function (app) {
     const io = require('socket.io')(app.get('server'));
     io.on('connection', socket => {
       let controller = null;
       socket.on('disconnect', reason => {
         if (controller) controller.abort();
       });
       // expose a hook that creates a fresh controller per call
       app.service('*/**').hooks({
         before: {
           all: [context => {
             controller = new AbortController();
             context.params = Object.assign({}, context.params, { signal: controller.signal });
             return context;
           }]
         }
       });
     });
   };

2. Read the signal in a service hook (e.g., a before hook on the target service):

   // src/services/my-service/my-service.hooks.js
   module.exports = {
     before: {
       find: [async context => {
         if (context.params.signal?.aborted) {
           throw new Error('Request cancelled by client disconnect');
         }
       }]
     }
   };

3. Wrap the database operation to respect the signal. Example for a generic pg query without native abort support:

   async function queryWithAbort(client, text, values, signal) {
     if (signal.aborted) {
       throw new Error('Aborted');
     }
     const queryPromise = client.query(text, values);
     return Promise.race([
       queryPromise,
       new Promise((_, reject) => {
         const abort = () => reject(new Error('Aborted'));
         signal.addEventListener('abort', abort, { once: true });
         // cleanup listener if query finishes first
         queryPromise.then(() => signal.removeEventListener('abort', abort)).catch(() => signal.removeEventListener('abort', abort));
       })
     ]);
   }
   // usage in service method
   const result = await queryWithAbort(pgClient, 'SELECT pg_sleep(10)', [], hook.params.signal);
   

4. Cleanup after abort – ensure any acquired resources are released:

   let client;
   try {
     client = await pool.connect();
     await queryWithAbort(client, 'SELECT pg_sleep(10)', [], hook.params.signal);
   } catch (err) {
     if (err.message === 'Aborted') {
       // log or metrics if desired
     }
     throw err;
   } finally {
     if (client) client.release(); // return to pool
   }
   

Caveats

• If the Socket.io provider is overridden or middleware swallows the disconnect event, the abort signal may never fire. Verify with logging in the before‑hook that signal.aborted flips to true on disconnect.
• Promise.race stops your code from waiting, but the server‑side query may keep running. Confirm actual termination with pg_stat_activity (PostgreSQL) or SHOW PROCESSLIST (MySQL); some drivers need an explicit cancel call.

Missing diagnostic detail

The exact cleanup steps depend on the database driver or ORM you are using (e.g., raw pg, mysql2, Sequelize, TypeORM). If the driver provides a native cancel method (like Sequelize’s query.cancel), you can call it instead of relying solely on Promise.race. Knowing which driver you employ will confirm whether a native abort path exists or if the wrapper approach is required.