first stab at error handler

package.json

@@ -24,7 +24,8 @@
     "cors": "^2.8.5",
     "express": "^4.21.1",
     "morgan": "^1.10.0",
-    "sqlite3": "^5.1.7"
+    "sqlite3": "^5.1.7",
+    "uid": "^2.0.2"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",

src/errors/errorType.ts

@@ -0,0 +1,4 @@
+export const enum ErrorType {
+    NOT_FOUND = "NOT_FOUND",
+    UNEXPECTED_ERROR = "UNEXPECTED_ERROR"
+}

src/errors/groutError.ts

@@ -0,0 +1,14 @@
+import {ErrorType} from "./errorType";
+
+export class GroutError extends Error {
+    status: number;
+    errorType: ErrorType;
+
+    constructor(message: string, status: number, errorType: ErrorType) {
+        super(message);
+
+        this.name = "GroutError";
+        this.status = status;
+        this.errorType = errorType;
+    }
+}

src/errors/handleError.ts

@@ -0,0 +1,24 @@
+import { Request, Response } from "express";
+import { uid } from "uid";
+import {GroutError} from "./groutError";
+import {ErrorType} from "./errorType";
+import {reqWithError} from "../logging";
+import {jsonResponseError} from "../jsonResponse";
+
+export const handleError = (err: Error, req: Request, res: Response, _: Function) => {
+    const groutError = err instanceof GroutError;
+
+    const status = groutError ? err.status : 500;
+    const type = groutError ? err.errorType : ErrorType.UNEXPECTED_ERROR;
+
+    // Do not return raw messages from unexpected errors to the front end
+    const detail = groutError ? err.message
+        : `An unexpected error occurred. Please contact support and quote error code ${uid()}`;
+
+    // Set error type, detail and stack on req so morgan logs them
+    reqWithError(req).errorType = type;
+    reqWithError(req).errorDetail = detail;
+    reqWithError(req).errorStack = err.stack;
+
+    jsonResponseError(status, type, detail, res);
+}

src/jsonResponse.ts

@@ -0,0 +1,24 @@
+import { Response } from "express";
+
+//TODO: use json response on success for index response (and metadata). Can't use it for tile data!
+const addContentType = (res: Response) => {
+    res.header("Content-Type", "application/json");
+};
+
+export const jsonResponseError = (
+    httpStatus: number,
+    error: string,
+    detail: string,
+    res: Response
+) => {
+    addContentType(res);
+    const responseObject = {
+        status: "failure",
+        errors: [
+            { error, detail }
+        ],
+        data: null
+    };
+    res.status(httpStatus);
+    res.end(JSON.stringify(responseObject));
+};

src/logging.ts

@@ -2,7 +2,19 @@ import { Application, Request, Response } from "express";
 import morgan from "morgan";
 import { Dict } from "./types/utils";
 
+interface RequestWithError {
+    errorType: string,
+    errorDetail: string,
+    errorStack: string | undefined
+}
+export const reqWithError = (req: Request) => (req as unknown) as RequestWithError;
+
 export const initialiseLogging = (app: Application) => {
+    // Log error details appended to request by handleError
+    morgan.token("error-type", (req: Request) => reqWithError(req).errorType);
+    morgan.token("error-detail", (req: Request) => reqWithError(req).errorDetail);
+    morgan.token("error-stack", (req: Request) => reqWithError(req).errorStack);
+
     const customFormat = (
         tokens: Dict<(req: Request, res: Response, header?: string) => string>,
         req: Request,
@@ -16,8 +28,10 @@ export const initialiseLogging = (app: Application) => {
             tokens.status(req, res),
             tokens.res(req, res, "content-length"),
             "-",
-            tokens["response-time"](req, res),
-            "ms"
+            tokens["response-time"](req, res), "ms",
+            tokens["error-type"](req),
+            tokens["error-detail"](req),
+            tokens["error-stack"](req)
         ].join(" ");
     };
 

src/server.ts

@@ -7,6 +7,7 @@ import { GroutConfig } from "./types/app";
 import { registerRoutes } from "./routes";
 import { initialiseLogging } from "./logging";
 import { discoverTileDatasets } from "./discover";
+import { handleError } from "../errors/handleError";
 
 const app = express();
 initialiseLogging(app);
@@ -28,6 +29,7 @@ Object.assign(app.locals, {
 });
 
 app.use("/", registerRoutes());
+app.use(handleError);
 
 app.listen(port, () => {
     console.log(`Grout is running on port ${port}`);