feat(request-id-middleware)

api/src/__tests__/auth.test.ts

@@ -1,4 +1,4 @@
 import { Request, Response, NextFunction } from 'express';
 import jwt from 'jsonwebtoken';
 import { authenticateToken, AuthRequest } from '../middleware/auth';
 import { UnauthorizedError } from '../utils/errors';
@@ -36,7 +36,7 @@
       authenticateToken(mockRequest as AuthRequest, mockResponse as Response, mockNext);
 
       expect(mockNext).toHaveBeenCalledWith();
-      expect(mockRequest.user).toEqual({ address: '0x1234567890123456789012345678901234567890' });
+      expect(mockRequest.user).toMatchObject({ address: '0x1234567890123456789012345678901234567890' });
     });
 
     it('should return 401 when token is missing', () => {

api/src/__tests__/bodySizeLimit.test.ts

@@ -8,18 +8,24 @@
   const createTestApp = (limit = config.bodySizeLimit.limit) => {
     const testApp = express();
     // Override the config for testing
     const originalLimit = config.bodySizeLimit.limit;
     config.bodySizeLimit.limit = limit;
     testApp.use(bodySizeLimitMiddleware);
     testApp.post('/test', (req, res) => {
       res.status(200).json({ success: true });
     });
     testApp.use(errorHandler);
-    // Restore original limit
-    config.bodySizeLimit.limit = originalLimit;
+    // Don't restore limit here because the request executes asynchronously later.
+    // Instead we'll manage it per-test or use a wrapper.
     return testApp;
   };
 
+  const originalLimit = config.bodySizeLimit.limit;
+
+  afterEach(() => {
+    config.bodySizeLimit.limit = originalLimit;
+  });
+
   describe('bodySizeLimitMiddleware', () => {
     it('should allow requests with body size within limit', async () => {
       const app = createTestApp('10kb');

api/src/app.ts

@@ -11,8 +11,11 @@ import { errorHandler } from './middleware/errorHandler';
 import { idempotencyMiddleware } from './middleware/idempotency';
 import { swaggerSpec } from './config/swagger';
 import logger from './utils/logger';
+import { requestIdMiddleware } from './middleware/requestId';
 
 const app: Application = express();
+app.use(requestIdMiddleware);
+
 const ipRateLimitStore = new MemoryStore();
 const userRateLimitStore = new MemoryStore();
 

api/src/middleware/__tests__/requestId.test.ts

@@ -0,0 +1,53 @@
+import { Request, Response, NextFunction } from 'express';
+import { requestIdMiddleware } from '../requestId';
+import { requestContext } from '../../utils/requestContext';
+
+describe('requestIdMiddleware', () => {
+  let mockRequest: Partial<Request>;
+  let mockResponse: Partial<Response>;
+  let nextFunction: NextFunction;
+
+  beforeEach(() => {
+    mockRequest = {
+      headers: {},
+    };
+    mockResponse = {
+      setHeader: jest.fn(),
+    };
+    nextFunction = jest.fn();
+  });
+
+  it('should generate a new UUID if x-request-id header is not present', () => {
+    requestIdMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+
+    expect(mockRequest.id).toBeDefined();
+    expect(typeof mockRequest.id).toBe('string');
+    expect(mockRequest.id?.length).toBeGreaterThan(0);
+    expect(mockResponse.setHeader).toHaveBeenCalledWith('x-request-id', mockRequest.id);
+    expect(nextFunction).toHaveBeenCalled();
+  });
+
+  it('should use incoming x-request-id header if present', () => {
+    mockRequest.headers = { 'x-request-id': 'test-req-id' };
+
+    requestIdMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+
+    expect(mockRequest.id).toBe('test-req-id');
+    expect(mockResponse.setHeader).toHaveBeenCalledWith('x-request-id', 'test-req-id');
+    expect(nextFunction).toHaveBeenCalled();
+  });
+
+  it('should run next function within async local storage context', (done) => {
+    nextFunction = jest.fn(() => {
+      try {
+        const storeId = requestContext.getStore();
+        expect(storeId).toBe(mockRequest.id);
+        done();
+      } catch (err) {
+        done(err);
+      }
+    });
+
+    requestIdMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+  });
+});

api/src/middleware/requestId.ts

@@ -0,0 +1,14 @@
+import { Request, Response, NextFunction } from 'express';
+import { randomUUID } from 'crypto';
+import { requestContext } from '../utils/requestContext';
+
+export const requestIdMiddleware = (req: Request, res: Response, next: NextFunction) => {
+  const reqId = req.headers['x-request-id'];
+  req.id = (Array.isArray(reqId) ? reqId[0] : reqId) || randomUUID();
+  res.setHeader('x-request-id', req.id);
+
+  // Set the request ID in the async local storage context for logger propagation
+  requestContext.run(req.id, () => {
+    next();
+  });
+};

api/src/types/express.d.ts

@@ -0,0 +1,7 @@
+import 'express';
+
+declare module 'express-serve-static-core' {
+  interface Request {
+    id: string;
+  }
+}

api/src/utils/errors.ts

@@ -25,35 +25,41 @@ export class ApiError extends Error {
 export class ValidationError extends ApiError {
   constructor(message: string) {
     super(400, message, ErrorCode.VALIDATION_ERROR);
+    Object.setPrototypeOf(this, ValidationError.prototype);
   }
 }
 
 export class UnauthorizedError extends ApiError {
   constructor(message = 'Unauthorized') {
     super(401, message, ErrorCode.UNAUTHORIZED);
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
   }
 }
 
 export class NotFoundError extends ApiError {
   constructor(message = 'Resource not found') {
     super(404, message, ErrorCode.NOT_FOUND);
+    Object.setPrototypeOf(this, NotFoundError.prototype);
   }
 }
 
 export class ConflictError extends ApiError {
   constructor(message: string) {
     super(409, message, ErrorCode.CONFLICT);
+    Object.setPrototypeOf(this, ConflictError.prototype);
   }
 }
 
 export class PayloadTooLargeError extends ApiError {
   constructor(message = 'Request body too large') {
-    super(413, message);
+    super(413, message, ErrorCode.VALIDATION_ERROR);
+    Object.setPrototypeOf(this, PayloadTooLargeError.prototype);
   }
 }
 
 export class InternalServerError extends ApiError {
   constructor(message = 'Internal server error') {
     super(500, message, ErrorCode.INTERNAL_SERVER_ERROR);
+    Object.setPrototypeOf(this, InternalServerError.prototype);
   }
 }

api/src/utils/logger.ts

@@ -1,9 +1,19 @@
 import winston from 'winston';
 import { config } from '../config';
+import { requestContext } from './requestContext';
+
+const addRequestId = winston.format((info: winston.Logform.TransformableInfo) => {
+  const reqId = requestContext.getStore();
+  if (reqId) {
+    info.requestId = reqId;
+  }
+  return info;
+});
 
 const logger = winston.createLogger({
   level: config.logging.level,
   format: winston.format.combine(
+    addRequestId(),
     winston.format.timestamp(),
     winston.format.errors({ stack: true }),
     winston.format.json()

api/src/utils/requestContext.ts

@@ -0,0 +1,3 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+export const requestContext = new AsyncLocalStorage<string>();