fase(7): api server refactor with composition root

dist/api/middleware/errorHandler.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.AuthenticationError = exports.ValidationError = exports.AppError = void 0;
+exports.globalErrorHandler = globalErrorHandler;
+class AppError extends Error {
+    constructor(message, statusCode, code, isOperational = true) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.isOperational = isOperational;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.AppError = AppError;
+class ValidationError extends AppError {
+    constructor(message, details) {
+        super(message, 400, 'VALIDATION_ERROR');
+        this.details = details;
+    }
+}
+exports.ValidationError = ValidationError;
+class AuthenticationError extends AppError {
+    constructor(message = 'Unauthorized') {
+        super(message, 401, 'AUTHENTICATION_ERROR');
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class ForbiddenError extends AppError {
+    constructor(message = 'Forbidden') {
+        super(message, 403, 'FORBIDDEN');
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class NotFoundError extends AppError {
+    constructor(resource) {
+        super(`${resource} not found`, 404, 'NOT_FOUND');
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends AppError {
+    constructor(message) {
+        super(message, 409, 'CONFLICT');
+    }
+}
+exports.ConflictError = ConflictError;
+class RateLimitError extends AppError {
+    constructor() {
+        super('Too many requests', 429, 'RATE_LIMIT');
+    }
+}
+exports.RateLimitError = RateLimitError;
+function globalErrorHandler(err, req, res, _next) {
+    const logger = req.log;
+    if (err instanceof AppError && err.isOperational) {
+        if (logger) {
+            logger.warn({ err, statusCode: err.statusCode }, err.message);
+        }
+        const body = { error: err.message, code: err.code };
+        if (err instanceof ValidationError && err.details !== undefined) {
+            body['details'] = err.details;
+        }
+        res.status(err.statusCode).json(body);
+        return;
+    }
+    if (logger) {
+        logger.error({ err }, 'Unhandled error');
+    }
+    else {
+        console.error('Unhandled error', err);
+    }
+    res.status(500).json({
+        error: process.env['NODE_ENV'] === 'production' ? 'Internal server error' : err.message,
+        code: 'INTERNAL_ERROR',
+    });
+}

dist/api/middleware/notFound.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundMiddleware = notFoundMiddleware;
+function notFoundMiddleware(req, res) {
+    res.status(404).json({
+        error: `Route ${req.method} ${req.path} not found`,
+        code: 'NOT_FOUND',
+    });
+}

dist/api/middleware/requestId.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestIdMiddleware = createRequestIdMiddleware;
+const uuid_1 = require("uuid");
+function createRequestIdMiddleware(logger) {
+    return (req, _res, next) => {
+        req.id = req.headers['x-request-id'] ?? (0, uuid_1.v4)();
+        req.log = logger.child({ requestId: req.id, method: req.method, url: req.url });
+        next();
+    };
+}