Replace a provider object during runtime - nestjs

Question

Let's say I have a module that provides a connection to something.
export const CONN string = 'CONN';
#Global()
#Module({})
export class ConnModule implements OnApplicationShutdown {
constructor(#Inject(CONN) private readonly conn: Connection) {}
onApplicationShutdown() {
this.conn.close();
}
static forRoot(options): DynamicModule {
const connectionProvider = {
provide: CONN,
useFactory: async (): Promise<Connection> => {
const connection = new Connection(options);
await connection.establish();
return connection;
},
};
return {
module: ConnModule ,
providers: [connectionProvider],
exports: [connectionProvider],
};
}
}
This connection is used through the application:
export class AService {
constructor(
#Inject(CONN) protected readonly conn: Connection,
) {}
someMethod() {
this.conn.doSomething(); // this may get 401ed
}
export class BService {
constructor(
#Inject(CONN) protected readonly conn: Connection,
) {}
otherMethod() {
this.conn.doSomethingElse(); // this may get 401ed
}
This is a connection to 3rd party app and it may start returning 401 anytime needing us to reauthenticate / recreate a connection.
How can I create a new connection on error and replace the current provider for all the modules that are using it?
Something like:
OnConnectionUnauthorizedException ->
create a new Connection ->
replace the current stale connection object that CONN provides with a new one ->
retry the original action
Thank you!

Answer 1

This sounds concerning to me. As it is hard to communicate to the outside what the status of your application is. Also, what will happen to processing events/requests during the time of the connection re-establishing? You are going to handle a lot of accidental complexity. Consider health checks at least to expose your application's status.
Yet there is a solution that I can imagine: Instead of providing the connection, provide a service that holds the connection in a private field. Make a getConection method, possibly async to gap disconnected times, and return the connection. This way you don't have to replace the injected value.
I would furthermore really discourage replacing an injected value. As this is really hard to communicate to code that might be dependent on this value. ("e.g. hey here is a new instance).
export class ConnectionService {
connection: Conection | undefined;
// Pro Tip: make getConnection async and leverage e.g. Promise.race to implement
// a timeout so that if the connection is down this code e.g. delays 5 seconds and
// if the connection gets re-established, answers with the new connection or throws
// a "Couldnt reconnect" error
getConnection(){
return this.connection;
}
}
This solution should be your last resort and instead, you should challenge the source of the required reconnect.