From 2eb12bb34cd3000be1b3827a0a336d385c5eab63 Mon Sep 17 00:00:00 2001 From: Jodson Graves Date: Mon, 2 Nov 2026 18:09:33 -0500 Subject: [PATCH] Return JSON errors without stack traces Express's default error handler answers with an HTML page that includes the stack trace and absolute file paths whenever NODE_ENV is not "production", and neither compose file sets it. Any request from an origin outside the CORS allow-list reached that handler as a 500. - Add middleware/errorHandler.js, registered after every route: always JSON, never the stack. 5xx responses carry only the status text and are logged server-side; 4xx responses show the message only when the error is marked safe to expose (as body-parser's are). - A refused CORS origin is now a 403 with a JSON message instead of a 500. - Tests cover the refused origin, a malformed JSON body, an unexpected throw and an unexposed 4xx. Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jodson Graves --- backend/__tests__/errorHandler.test.js | 53 ++++++++++++++++++++++++++ backend/middleware/errorHandler.js | 10 +++++ backend/server.js | 8 +++- 3 files changed, 70 insertions(+), 1 deletion(-) create mode 100644 backend/__tests__/errorHandler.test.js create mode 100644 backend/middleware/errorHandler.js diff --git a/backend/__tests__/errorHandler.test.js b/backend/__tests__/errorHandler.test.js new file mode 100644 index 00000000..d8b0b280 --- /dev/null +++ b/backend/__tests__/errorHandler.test.js @@ -0,0 +1,53 @@ +const { test } = require('node:test'); +const assert = require('node:assert/strict'); +const express = require('express'); +const request = require('supertest'); +const errorHandler = require('../middleware/errorHandler'); + +function loadMinimalServer(t) { + const priorMinimal = process.env.MINIMAL_SERVER; + process.env.MINIMAL_SERVER = 'true'; + t.after(() => { + if (priorMinimal === undefined) delete process.env.MINIMAL_SERVER; else process.env.MINIMAL_SERVER = priorMinimal; + }); + return require('../server').app; +} + +test('a refused CORS origin gets a JSON 403, not an error page', async (t) => { + const app = loadMinimalServer(t); + const response = await request(app).get('/health').set('Origin', 'https://elsewhere.example'); + assert.equal(response.status, 403); + assert.match(response.headers['content-type'], /application\/json/); + assert.deepEqual(response.body, { error: 'CORS not allowed for this origin' }); +}); + +test('a malformed JSON body gets a JSON 400 without a stack trace', async (t) => { + const app = loadMinimalServer(t); + const response = await request(app).post('/health') + .set('Content-Type', 'application/json').send('{"broken":'); + assert.equal(response.status, 400); + assert.match(response.headers['content-type'], /application\/json/); + assert.deepEqual(Object.keys(response.body), ['error']); + assert.doesNotMatch(response.text, /\bat \S+ \(|node_modules|[\\/]backend[\\/]/); +}); + +test('an unexpected error gets a generic JSON 500', async (t) => { + const originalError = console.error; + console.error = () => {}; + t.after(() => { console.error = originalError; }); + const app = express(); + app.get('/boom', () => { throw new Error('secret detail at /srv/app/backend/x.js'); }); + app.use(errorHandler); + const response = await request(app).get('/boom'); + assert.equal(response.status, 500); + assert.deepEqual(response.body, { error: 'Internal Server Error' }); +}); + +test('a client error that is not marked safe to show keeps only its status text', async () => { + const app = express(); + app.get('/teapot', (_req, _res, next) => next(Object.assign(new Error('internal reason'), { status: 418 }))); + app.use(errorHandler); + const response = await request(app).get('/teapot'); + assert.equal(response.status, 418); + assert.deepEqual(response.body, { error: "I'm a Teapot" }); +}); diff --git a/backend/middleware/errorHandler.js b/backend/middleware/errorHandler.js new file mode 100644 index 00000000..f320bdab --- /dev/null +++ b/backend/middleware/errorHandler.js @@ -0,0 +1,10 @@ +const { STATUS_CODES } = require('http'); + +// Last-resort error handler: always JSON, never a stack trace or file path, +// whatever NODE_ENV is. Register it after every route. +module.exports = (err, req, res, next) => { + if (res.headersSent) return next(err); + const status = Number.isInteger(err.status) && err.status >= 400 && err.status < 600 ? err.status : 500; + if (status >= 500) console.error(err); + res.status(status).json({ error: status < 500 && err.expose ? err.message : STATUS_CODES[status] }); +}; diff --git a/backend/server.js b/backend/server.js index 7a827381..aaa3cb7d 100644 --- a/backend/server.js +++ b/backend/server.js @@ -14,6 +14,7 @@ try { } const path = require("path"); const authMiddleware = require("./middleware/authMiddleware"); +const errorHandler = require("./middleware/errorHandler"); // Load environment variables dotenv.config(); @@ -29,7 +30,10 @@ app.use(cors({ if (!origin || allowedOrigins.includes(origin)) { callback(null, true); } else { - callback(new Error('CORS not allowed for this origin')); + const err = new Error('CORS not allowed for this origin'); + err.status = 403; + err.expose = true; + callback(err); } }, credentials: true, @@ -164,6 +168,8 @@ if (!minimal) { } } +app.use(errorHandler); + const PORT = process.env.PORT || 5000; if (require.main === module) { server.listen(PORT, () => console.log(`Server running on port ${PORT}`));