feat: add response compression middleware with gzip and brotli support

backend/package.json

@@ -33,13 +33,14 @@
     "python:setup": "python -m spacy download en_core_web_sm"
   },
   "dependencies": {
-    "@noble/post-quantum": "^0.2.1",
     "@elastic/elasticsearch": "^9.4.2",
+    "@noble/post-quantum": "^0.2.1",
     "@stellar/stellar-sdk": "^14.5.0",
     "aws-sdk": "^2.1693.0",
     "axios": "^1.5.0",
     "bcryptjs": "^2.4.3",
     "brain.js": "^2.0.0-beta.24",
+    "compression": "^1.8.1",
     "compromise": "^14.10.0",
     "cors": "^2.8.5",
     "d3": "^7.8.5",

backend/src/index.js

@@ -27,6 +27,9 @@ const {
 const { globalLimiter } = require('./middleware/rateLimiter');
 const { authenticateToken, requireAdmin } = require('./middleware/auth');
 
+// Import compression middleware
+const { compressionMiddleware } = require('./middleware/compression');
+
 // Import versioning middleware
 const { versionExtractor, createVersionedRouter, SUPPORTED_VERSIONS, DEFAULT_VERSION } = require('./middleware/versioning');
 
@@ -105,6 +108,10 @@ setSyncWebsocketEmitter((userId, event, data) => {
 // Middleware
 app.use(helmet());
 app.use(cors());
+
+// Response compression - early in pipeline to compress all outgoing responses
+app.use(compressionMiddleware());
+
 app.use(express.json({ limit: '10mb' }));
 app.use(express.urlencoded({ extended: true }));
 
@@ -190,6 +197,7 @@ app.use('/api/v2', v2Router);
 const { createVersionedResponse } = require('./utils/schemas');
 const { errorHandler, notFoundHandler } = require('./middleware/errorHandler');
 const { ValidationError } = require('./utils/errors');
+const { getCompressionStats } = require('./middleware/compression');
 
 // Root endpoint
 app.get('/', (req, res) => {
@@ -208,6 +216,7 @@ app.get('/api/health', (req, res) => {
     status: 'healthy',
     uptime: process.uptime(),
     supportedVersions: SUPPORTED_VERSIONS,
+    compression: getCompressionStats(),
   }, version));
 });
 

backend/src/middleware/compression.ts

@@ -0,0 +1,151 @@
+import { Request, Response, NextFunction } from 'express';
+import zlib from 'zlib';
+
+const COMPRESSIBLE_TYPES = [
+  'application/json',
+  'text/html',
+  'text/css',
+  'application/javascript',
+  'text/plain',
+  'application/xml',
+];
+
+const SKIPPED_PREFIXES = ['image/', 'video/', 'audio/'];
+
+const DEFAULT_THRESHOLD = 1024;
+
+const MAX_STATS_ENTRIES = 1000;
+
+interface StatsEntry {
+  originalBytes: number;
+  compressedBytes: number;
+  timeMs: number;
+}
+
+const statsEntries: StatsEntry[] = [];
+
+function getEncoding(req: Request): 'br' | 'gzip' | null {
+  const acceptEncoding = (req.headers['accept-encoding'] as string) || '';
+  if (acceptEncoding.includes('br')) return 'br';
+  if (acceptEncoding.includes('gzip')) return 'gzip';
+  return null;
+}
+
+function shouldCompress(req: Request, res: Response): boolean {
+  if (res.getHeader('x-no-compression')) return false;
+  const contentType = (res.getHeader('content-type') as string) || '';
+  if (!contentType) return false;
+  for (const prefix of SKIPPED_PREFIXES) {
+    if (contentType.startsWith(prefix)) return false;
+  }
+  return COMPRESSIBLE_TYPES.some(t => contentType.startsWith(t));
+}
+
+function compressBuffer(data: Buffer, encoding: 'br' | 'gzip', level: number, quality: number): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    if (encoding === 'br') {
+      zlib.brotliCompress(
+        data,
+        { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: quality } },
+        (err, result) => (err ? reject(err) : resolve(result))
+      );
+    } else {
+      zlib.gzip(data, { level }, (err, result) => (err ? reject(err) : resolve(result)));
+    }
+  });
+}
+
+export interface CompressionOptions {
+  level?: number;
+  brotliQuality?: number;
+  threshold?: number;
+}
+
+export function compressionMiddleware(opts: CompressionOptions = {}) {
+  const level = opts.level ?? 6;
+  const quality = opts.brotliQuality ?? 4;
+  const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    const encoding = getEncoding(req);
+    if (!encoding) {
+      res.setHeader('Vary', 'Accept-Encoding');
+      return next();
+    }
+
+    const originalWrite = res.write.bind(res);
+    const originalEnd = res.end.bind(res);
+    const chunks: Buffer[] = [];
+
+    res.write = function (this: Response, chunk: any, ...args: any[]): boolean {
+      if (chunk) chunks.push(Buffer.from(chunk));
+      return true;
+    } as any;
+
+    res.end = function (this: Response, chunk?: any, ...args: any[]): any {
+      res.write = originalWrite;
+      res.end = originalEnd;
+
+      if (chunk) chunks.push(Buffer.from(chunk));
+      const body = Buffer.concat(chunks);
+
+      res.setHeader('Vary', 'Accept-Encoding');
+
+      if (!shouldCompress(req, res) || body.length < threshold) {
+        return originalEnd(chunk, ...args);
+      }
+
+      const start = Date.now();
+
+      compressBuffer(body, encoding, level, quality)
+        .then(compressed => {
+          const elapsed = Date.now() - start;
+
+          statsEntries.push({
+            originalBytes: body.length,
+            compressedBytes: compressed.length,
+            timeMs: elapsed,
+          });
+          if (statsEntries.length > MAX_STATS_ENTRIES) {
+            statsEntries.shift();
+          }
+
+          res.removeHeader('Content-Length');
+          res.setHeader('Content-Encoding', encoding);
+          originalEnd(compressed);
+        })
+        .catch(err => {
+          console.error('Compression error:', err);
+          originalEnd(body);
+        });
+    } as any;
+
+    next();
+  };
+}
+
+export function getCompressionStats() {
+  const total = statsEntries.reduce(
+    (acc, e) => ({
+      originalBytes: acc.originalBytes + e.originalBytes,
+      compressedBytes: acc.compressedBytes + e.compressedBytes,
+      timeMs: acc.timeMs + e.timeMs,
+    }),
+    { originalBytes: 0, compressedBytes: 0, timeMs: 0 }
+  );
+
+  const count = statsEntries.length;
+
+  return {
+    enabled: true,
+    total_original_bytes: total.originalBytes,
+    total_compressed_bytes: total.compressedBytes,
+    total_time_ms: total.timeMs,
+    compressed_count: count,
+    avg_ratio:
+      count > 0 && total.originalBytes > 0
+        ? Number((total.compressedBytes / total.originalBytes).toFixed(4))
+        : 1,
+    avg_time_ms: count > 0 ? Number((total.timeMs / count).toFixed(2)) : 0,
+  };
+}

backend/src/routes/health.ts

@@ -22,6 +22,7 @@
 import { Router, Request, Response } from 'express';
 import axios from 'axios';
 import { checkDatabaseConnectivity, DependencyHealth } from '../utils/database';
+import { getCompressionStats } from '../middleware/compression';
 
 const router: Router = Router();
 
@@ -200,6 +201,7 @@ router.get('/', async (req: Request, res: Response) => {
       version: packageJson.version,
       uptime: process.uptime(),
       timestamp: new Date().toISOString(),
+      compression: getCompressionStats(),
       memory: {
         heapUsed: memory.heapUsed,
         heapTotal: memory.heapTotal,
@@ -235,6 +237,7 @@ router.get('/', async (req: Request, res: Response) => {
       version: packageJson.version,
       uptime: process.uptime(),
       timestamp: new Date().toISOString(),
+      compression: getCompressionStats(),
       memory: {
         heapUsed: 0,
         heapTotal: 0,