Question: Today, the behavior of Typeorm (Postgres) for

* `getManager().query(...)` and
* `getRepositoty().createQueryBuilder(...).getMany()`

is to wait for a response indefinitely.

Is there a way to introduce a request timeout that I might've missed?

If this is not possible, does Typeorm expose the connection from its pool so that I can implement a timeout mechanism and close the DB connection manually?

Answer: 
To work with a specific connection from the pool use `createQueryRunner` there is no info about it in the docs but it is documented in the [api](https://typeorm.delightful.studio/classes/_connection_connection_.connection.html).

> 
> Creates a query runner used for perform queries on a single database connection.
> Using query runners you can control your queries to execute using single database connection and
> manually control your database transaction.
> 
> 
> 

Usage example:

```
const foo = <T>(callback: <T>(em: EntityManager) => Promise<T>): Promise<T> => {
    const connection = getConnection();
    const queryRunner = connection.createQueryRunner();

    return new Promise(async (resolve, reject) => {
        let res: T;
        try {
            await queryRunner.connect();
            // add logic for timeout
            res = await callback(queryRunner.manager);
        } catch (err) {
            reject(err);
        } finally {
            await queryRunner.release();
            resolve(res);
        }
    });
};

```
[from the documentation](https://typeorm.io/#/connection-options/common-connection-options) you can use `maxQueryExecutionTime` ConnectionOption.

`maxQueryExecutionTime` - If query execution time exceed this given max execution time (in milliseconds) then logger will log this query.

ConnectionOptions is a connection configuration you pass to `createConnection` or define in `ormconfig`