feat(db): add query timeout with config override and request context logging

Author: shogun444

.env.example

@@ -5,6 +5,7 @@ FRONTEND_URL=http://localhost:5173
 
 # Docker Postgres defaults
 DATABASE_URL=postgresql://postgres:postgres@localhost:5432/accesslayer
+DB_QUERY_TIMEOUT_MS=5000
 
 GOOGLE_CLIENT_ID=
 GOOGLE_CLIENT_SECRET=

src/app.ts

@@ -13,13 +13,15 @@ import { requestIdMiddleware } from './middlewares/request-id.middleware';
 import { responseTimingMiddleware } from './middlewares/response-timing.middleware';
 import { apiVersionMiddleware } from './middlewares/api-version.middleware';
 import { requestLoggerMiddleware } from './middlewares/request-logger.middleware';
+import { requestContextMiddleware } from './middlewares/request-context.middleware';
 import { envConfig } from './config';
 
 const app: Express = express();
 
 // Middleware setup
 app.set('trust proxy', 1);
 app.use(responseTimingMiddleware);
+app.use(requestContextMiddleware);
 app.use(apiVersionMiddleware);
 app.use(requestIdMiddleware);
 app.use(corsMiddleware());

src/config.ts

@@ -49,6 +49,7 @@ export const envSchema = z.object({
    API_VERSION: z.string().default('1.0.0'),
    ENABLE_API_VERSION_HEADER: z.coerce.boolean().default(true),
    ENABLE_REQUEST_LOGGING: z.coerce.boolean().default(true),
+   DB_QUERY_TIMEOUT_MS: z.coerce.number().default(5000),
 });
 
 export const envConfig = envSchema.parse(process.env);

src/middlewares/request-context.middleware.ts

@@ -0,0 +1,18 @@
+import { Request, Response, NextFunction } from 'express';
+import { requestContextStorage } from '../utils/als.utils';
+
+export const requestContextMiddleware = (
+  req: Request,
+  _res: Response,
+  next: NextFunction
+): void => {
+  const context = {
+    path: req.originalUrl || req.url,
+    method: req.method,
+    requestId: req.requestId as string | undefined,
+  };
+
+  requestContextStorage.run(context, () => {
+    next();
+  });
+};

src/utils/als.utils.ts

@@ -0,0 +1,9 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+export interface RequestContext {
+  path: string;
+  method: string;
+  requestId?: string;
+}
+
+export const requestContextStorage = new AsyncLocalStorage<RequestContext>();

src/utils/prisma.utils.ts

@@ -1,23 +1,52 @@
 import { PrismaClient } from '@prisma/client';
 import { envConfig } from '../config';
+import { requestContextStorage } from './als.utils';
+import { logger } from './logger.utils';
 
 // Use global variable to prevent multiple instances in development
-// See: https://www.prisma.io/docs/guides/performance-and-optimization/connection-management
-
 declare global {
-   var prisma: PrismaClient | undefined;
+   var prisma: any | undefined;
 }
 
-// Export a singleton PrismaClient instance
-export const prisma =
-   global.prisma ||
-   new PrismaClient({
-      log:
-         envConfig.MODE === 'development'
-            ? ['query', 'error', 'warn']
-            : ['error'],
-      datasourceUrl: envConfig.DATABASE_URL,
-   });
+const basePrisma = new PrismaClient({
+   log:
+      envConfig.MODE === 'development'
+         ? ['query', 'error', 'warn']
+         : ['error'],
+   datasourceUrl: envConfig.DATABASE_URL,
+});
+
+// Extend Prisma with query timeout
+export const prisma = basePrisma.$extends({
+   query: {
+      $allOperations({ operation, model, args, query }) {
+         const timeoutMs = envConfig.DB_QUERY_TIMEOUT_MS;
+         const context = requestContextStorage.getStore();
+
+         let timeoutId: NodeJS.Timeout;
+         const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+               const logContext = {
+                  type: 'database_timeout',
+                  operation,
+                  model,
+                  timeoutMs,
+                  path: context?.path,
+                  method: context?.method,
+                  requestId: context?.requestId,
+               };
+               logger.error(logContext, `Database query timed out after ${timeoutMs}ms`);
+               reject(new Error(`Database query timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+         });
+
+         return Promise.race([
+            query(args).finally(() => clearTimeout(timeoutId)),
+            timeoutPromise,
+         ]);
+      },
+   },
+});
 
 // Prevent multiple instances in development environment
 if (envConfig.MODE !== 'production') {