@manojkmfsi/monodog 1.0.24 → 1.1.0

package/src/constants/security.ts

@@ -0,0 +1,78 @@
+/**
+ * Security Constants
+ * Defines security-related configuration and constants
+ */
+
+/**
+ * Request timeout duration in milliseconds (30 seconds)
+ */
+export const REQUEST_TIMEOUT = 30000;
+
+/**
+ * Response timeout duration in milliseconds (30 seconds)
+ */
+export const RESPONSE_TIMEOUT = 30000;
+
+/**
+ * CORS methods allowed for API
+ */
+export const CORS_API_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'] as const;
+
+/**
+ * CORS headers allowed
+ */
+export const CORS_ALLOWED_HEADERS = ['Content-Type', 'Authorization'] as const;
+
+/**
+ * Body parser JSON size limit
+ */
+export const BODY_PARSER_LIMIT = '1mb';
+
+/**
+ * Cache control header for no-cache responses
+ */
+export const CACHE_CONTROL_NO_CACHE = 'private, no-cache, no-store, must-revalidate';
+
+/**
+ * Cache control header for static assets
+ */
+export const CACHE_CONTROL_STATIC = '1d';
+
+/**
+ * Default localhost hostname
+ */
+export const DEFAULT_LOCALHOST = 'localhost';
+
+/**
+ * Wildcard address for listening on all interfaces
+ */
+export const WILDCARD_ADDRESS = '0.0.0.0';
+
+/**
+ * HTTP protocol prefix
+ */
+export const HTTP_PROTOCOL = 'http://';
+
+/**
+ * CSP directives for Helmet
+ */
+export const CSP_DIRECTIVES = {
+  defaultSrc: ["'self'"],
+  scriptSrc: ["'self'"],
+  imgSrc: ["'self'", 'data:', 'https:'],
+} as const;
+
+/**
+ * Static file extensions pattern
+ */
+export const STATIC_FILE_PATTERN = /(.ico|.js|.css|.jpg|.png|.map|.woff|.woff2|.ttf)$/i;
+
+/**
+ * Expires header for no-cache responses
+ */
+export const EXPIRES_HEADER = '-1';
+
+/**
+ * Pragma header for no-cache responses
+ */
+export const PRAGMA_HEADER = 'no-cache';

package/src/middleware/dashboard-startup.ts

@@ -5,11 +5,11 @@
 import express from 'express';
 import path from 'path';
 import type { Express } from 'express';
+import { httpLogger, AppLogger } from './logger';
 
 import { appConfig } from '../config-loader';
 import {
   errorHandler,
-  requestLogger,
 } from './error-handler';
 import {
   createHelmetMiddleware,
@@ -17,10 +17,23 @@ import {
   createTimeoutMiddleware,
   buildApiUrl,
 } from './security';
-
-// Security constants
-const PORT_MIN = 1024;
-const PORT_MAX = 65535;
+import {
+  PORT_MIN,
+  PORT_MAX,
+  PORT_VALIDATION_ERROR_MESSAGE,
+  CACHE_CONTROL_NO_CACHE,
+  EXPIRES_HEADER,
+  PRAGMA_HEADER,
+  STATIC_FILE_PATTERN,
+  CONTENT_TYPE_JAVASCRIPT,
+  ERROR_SERVING_INDEX_HTML,
+  MESSAGE_GRACEFUL_SHUTDOWN,
+  MESSAGE_DASHBOARD_GRACEFUL_SHUTDOWN,
+  MESSAGE_DASHBOARD_CLOSED,
+  SUCCESS_DASHBOARD_START,
+  ERROR_PORT_IN_USE,
+  ERROR_PERMISSION_DENIED,
+} from '../constants';
 
 /**
  * Validate port number
@@ -29,7 +42,7 @@ function validatePort(port: string | number): number {
   const portNum = typeof port === 'string' ? parseInt(port, 10) : port;
 
   if (isNaN(portNum) || portNum < PORT_MIN || portNum > PORT_MAX) {
-    throw new Error(`Port must be between ${PORT_MIN} and ${PORT_MAX}`);
+    throw new Error(PORT_VALIDATION_ERROR_MESSAGE(PORT_MIN, PORT_MAX));
   }
 
   return portNum;
@@ -55,8 +68,8 @@ function createDashboardApp(): Express {
 
   // Environment config endpoint
   app.get('/env-config.js', (_req, res) => {
-    res.setHeader('Content-Type', 'application/javascript');
-    res.setHeader('Cache-Control', 'private, no-cache, no-store, must-revalidate');
+    res.setHeader('Content-Type', CONTENT_TYPE_JAVASCRIPT);
+    res.setHeader('Cache-Control', CACHE_CONTROL_NO_CACHE);
 
     res.send(
       `window.ENV = { API_URL: "${apiUrl}" };`
@@ -64,24 +77,24 @@ function createDashboardApp(): Express {
   });
 
   // Request logging
-  app.use(requestLogger);
+  app.use(httpLogger);
 
   // SPA routing: serve index.html for non-static routes
   app.use((_req, _res, next) => {
-    if (/(.ico|.js|.css|.jpg|.png|.map|.woff|.woff2|.ttf)$/i.test(_req.path)) {
+    if (STATIC_FILE_PATTERN.test(_req.path)) {
       next();
     } else {
       _res.header(
         'Cache-Control',
-        'private, no-cache, no-store, must-revalidate'
+        CACHE_CONTROL_NO_CACHE
       );
-      _res.header('Expires', '-1');
-      _res.header('Pragma', 'no-cache');
+      _res.header('Expires', EXPIRES_HEADER);
+      _res.header('Pragma', PRAGMA_HEADER);
       _res.sendFile('index.html', {
         root: path.resolve(__dirname, '..', '..', 'monodog-dashboard', 'dist'),
       }, (err: Error | null) => {
         if (err) {
-          console.error('Error serving index.html:', (err as Error & { message?: string })?.message);
+          AppLogger.error(ERROR_SERVING_INDEX_HTML, err);
           _res.status(500).json({ error: 'Internal server error' });
         }
       });
@@ -90,7 +103,7 @@ function createDashboardApp(): Express {
 
   // Static files
   const staticPath = path.join(__dirname, '..', '..', 'monodog-dashboard', 'dist');
-  console.log('Serving static files from:', staticPath);
+  AppLogger.debug('Serving static files from:', { path: staticPath });
   app.use(express.static(staticPath, {
     maxAge: '1d',
     etag: false,
@@ -115,36 +128,34 @@ export function serveDashboard(rootPath: string): void {
     const app = createDashboardApp();
 
     const server = app.listen(validatedPort, host, () => {
-      console.log(`Dashboard listening on http://${host}:${validatedPort}`);
+      console.log(SUCCESS_DASHBOARD_START(host, validatedPort));
       console.log('Press Ctrl+C to quit.');
     });
 
     server.on('error', (err: NodeJS.ErrnoException) => {
       if (err.code === 'EADDRINUSE') {
-        console.error(`Error: Port ${validatedPort} is already in use.`);
+        AppLogger.error(ERROR_PORT_IN_USE(validatedPort), err);
         process.exit(1);
       } else if (err.code === 'EACCES') {
-        console.error(
-          `Error: Permission denied to listen on port ${validatedPort}.`
-        );
+        AppLogger.error(ERROR_PERMISSION_DENIED(validatedPort), err);
         process.exit(1);
       } else {
-        console.error('Server failed to start:', err.message);
+        AppLogger.error('Server failed to start:', err);
         process.exit(1);
       }
     });
 
     // Graceful shutdown
     process.on('SIGTERM', () => {
-      console.log('SIGTERM signal received: closing dashboard server');
+      AppLogger.info(MESSAGE_DASHBOARD_GRACEFUL_SHUTDOWN);
       server.close(() => {
-        console.log('Dashboard server closed');
+        AppLogger.info(MESSAGE_DASHBOARD_CLOSED);
         process.exit(0);
       });
     });
   } catch (error: unknown) {
     const err = error as Error & { message?: string };
-    console.error('Failed to start dashboard:', err?.message || String(error));
+    AppLogger.error('Failed to start dashboard:', err);
     process.exit(1);
   }
 }

package/src/middleware/error-handler.ts

@@ -3,6 +3,7 @@
  */
 
 import { Request, Response, NextFunction, ErrorRequestHandler } from 'express';
+import { AppLogger } from './logger';
 
 /**
  * Custom error interface extending Error
@@ -24,7 +25,7 @@ export const errorHandler: ErrorRequestHandler = (
 ): void => {
   const status = err.status || err.statusCode || 500;
 
-  console.error('[ERROR]', {
+  AppLogger.error('Request error occurred', {
     status,
     method: req.method,
     path: req.path,
@@ -47,17 +48,3 @@ export const notFoundHandler = (_req: Request, res: Response): void => {
     timestamp: Date.now(),
   });
 };
-
-/**
- * Request logging middleware
- */
-export const requestLogger = (
-  req: Request,
-  _res: Response,
-  next: NextFunction
-): void => {
-  console.log(
-    `[${new Date().toISOString()}] ${req.method} ${req.path}`
-  );
-  next();
-};

package/src/middleware/index.ts

@@ -2,7 +2,7 @@
  * Middleware exports
  */
 
-export { errorHandler, notFoundHandler, requestLogger } from './error-handler';
+export { errorHandler, notFoundHandler } from './error-handler';
 export type { CustomError } from './error-handler';
 
 export {
@@ -16,3 +16,5 @@ export {
 
 export { startServer } from './server-startup';
 export { serveDashboard } from './dashboard-startup';
+
+export { httpLogger, AppLogger } from './logger';

package/src/middleware/logger.ts

@@ -0,0 +1,58 @@
+/**
+ * Logger configuration using Morgan
+ */
+
+import morgan from 'morgan';
+
+/**
+ * HTTP request logger middleware using Morgan
+ */
+export const httpLogger = morgan('dev');
+
+/**
+ * Application logger for non-HTTP events
+ */
+export class AppLogger {
+  private static readonly prefix = '[APP]';
+
+  static info(message: string, data?: Record<string, unknown>): void {
+    if (process.env.LOG_LEVEL == 'info' || process.env.LOG_LEVEL == 'debug') {
+      if (data) {
+        console.log(`${this.prefix} [INFO]`, message, JSON.stringify(data, null, 2));
+      } else {
+        console.log(`${this.prefix} [INFO]`, message);
+      }
+    }
+  }
+
+  static error(message: string, error?: Error | Record<string, unknown>): void {
+    if (error instanceof Error) {
+      console.error(`${this.prefix} [ERROR]`, message, {
+        message: error.message,
+        stack: error.stack,
+      });
+    } else if (error) {
+      console.error(`${this.prefix} [ERROR]`, message, error);
+    } else {
+      console.error(`${this.prefix} [ERROR]`, message);
+    }
+  }
+
+  static warn(message: string, data?: Record<string, unknown>): void {
+    if (data) {
+      console.warn(`${this.prefix} [WARN]`, message, JSON.stringify(data, null, 2));
+    } else {
+      console.warn(`${this.prefix} [WARN]`, message);
+    }
+  }
+
+  static debug(message: string, data?: Record<string, unknown>): void {
+    if (process.env.LOG_LEVEL == 'debug') {
+      if (data) {
+        console.log(`${this.prefix} [DEBUG]`, message, JSON.stringify(data, null, 2));
+      } else {
+        console.log(`${this.prefix} [DEBUG]`, message);
+      }
+    }
+  }
+}

package/src/middleware/security.ts

@@ -6,6 +6,15 @@ import { Request, Response, NextFunction } from 'express';
 import helmet from 'helmet';
 import cors, { CorsOptions } from 'cors';
 import type { MonodogConfig } from '../types/config';
+import {
+  REQUEST_TIMEOUT,
+  RESPONSE_TIMEOUT,
+  CORS_API_METHODS,
+  CORS_ALLOWED_HEADERS,
+  DEFAULT_LOCALHOST,
+  WILDCARD_ADDRESS,
+  HTTP_PROTOCOL,
+} from '../constants';
 
 /**
  * Create Helmet security middleware with Content Security Policy
@@ -28,10 +37,10 @@ export function createHelmetMiddleware(apiUrl: string) {
  */
 export function createApiCorsMiddleware(dashboardUrl: string) {
   const corsOptions: CorsOptions = {
-    origin: process.env.CORS_ORIGIN || dashboardUrl,
+    origin: dashboardUrl,
     credentials: true,
-    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-    allowedHeaders: ['Content-Type', 'Authorization'],
+    methods: [...CORS_API_METHODS],
+    allowedHeaders: [...CORS_ALLOWED_HEADERS],
   };
 
   return cors(corsOptions);
@@ -53,8 +62,8 @@ export function createDashboardCorsMiddleware() {
  */
 export function createTimeoutMiddleware() {
   return (req: Request, res: Response, next: NextFunction): void => {
-    req.setTimeout(30000);
-    res.setTimeout(30000);
+    req.setTimeout(REQUEST_TIMEOUT);
+    res.setTimeout(RESPONSE_TIMEOUT);
     next();
   };
 }
@@ -66,16 +75,16 @@ export function buildApiUrl(
   host: string,
   port: number
 ): string {
-  const apiHost = host === '0.0.0.0' ? 'localhost' : host;
-  return process.env.API_URL || `http://${apiHost}:${port}`;
+  const apiHost = host === WILDCARD_ADDRESS ? DEFAULT_LOCALHOST : host;
+  return `${HTTP_PROTOCOL}${apiHost}:${port}`;
 }
 
 /**
  * Build dashboard URL based on config
  */
 export function buildDashboardUrl(config: MonodogConfig): string {
-  const dashboardHost = config.dashboard.host === '0.0.0.0' 
-    ? 'localhost' 
+  const dashboardHost = config.dashboard.host === WILDCARD_ADDRESS
+    ? DEFAULT_LOCALHOST
     : config.dashboard.host;
-  return `http://${dashboardHost}:${config.dashboard.port}`;
+  return `${HTTP_PROTOCOL}${dashboardHost}:${config.dashboard.port}`;
 }

package/src/middleware/server-startup.ts

@@ -5,12 +5,12 @@
 import express from 'express';
 import { json } from 'body-parser';
 import type { Express } from 'express';
+import { httpLogger, AppLogger } from './logger';
 
 import { appConfig } from '../config-loader';
 import {
   errorHandler,
   notFoundHandler,
-  requestLogger,
 } from './error-handler';
 import {
   createHelmetMiddleware,
@@ -19,15 +19,23 @@ import {
   buildApiUrl,
   buildDashboardUrl,
 } from './security';
+import { setupSwaggerDocs } from './swagger-middleware';
 
 import packageRouter from '../routes/package-routes';
 import commitRouter from '../routes/commit-routes';
 import healthRouter from '../routes/health-routes';
 import configRouter from '../routes/config-routes';
-
-// Security constants
-const PORT_MIN = 1024;
-const PORT_MAX = 65535;
+import {
+  PORT_MIN,
+  PORT_MAX,
+  PORT_VALIDATION_ERROR_MESSAGE,
+  BODY_PARSER_LIMIT,
+  SUCCESS_SERVER_START,
+  ERROR_PORT_IN_USE,
+  ERROR_PERMISSION_DENIED,
+  MESSAGE_GRACEFUL_SHUTDOWN,
+  MESSAGE_SERVER_CLOSED,
+} from '../constants';
 
 /**
  * Validate port number
@@ -36,7 +44,7 @@ function validatePort(port: string | number): number {
   const portNum = typeof port === 'string' ? parseInt(port, 10) : port;
 
   if (isNaN(portNum) || portNum < PORT_MIN || portNum > PORT_MAX) {
-    throw new Error(`Port must be between ${PORT_MIN} and ${PORT_MAX}`);
+    throw new Error(PORT_VALIDATION_ERROR_MESSAGE(PORT_MIN, PORT_MAX));
   }
 
   return portNum;
@@ -62,10 +70,13 @@ function createApp(rootPath: string): Express {
   app.use(createApiCorsMiddleware(dashboardUrl));
 
   // Body parser
-  app.use(json({ limit: '1mb' }));
+  app.use(json({ limit: BODY_PARSER_LIMIT }));
+
+  // HTTP request logging with Morgan
+  app.use(httpLogger);
 
-  // Request logging
-  app.use(requestLogger);
+  // Setup Swagger documentation
+  setupSwaggerDocs(app);
 
   // Routes
   app.use('/api/packages', packageRouter);
@@ -91,50 +102,52 @@ export function startServer(rootPath: string): void {
     const host = appConfig.server.host;
     const validatedPort = validatePort(port);
 
+    AppLogger.info(`Starting Monodog API server...`);
+    AppLogger.info(`Analyzing monorepo at root: ${rootPath}`);
+
     const app = createApp(rootPath);
 
     const server = app.listen(validatedPort, host, () => {
-      console.log(`Backend server running on http://${host}:${validatedPort}`);
-      console.log('API endpoints available:');
-      console.log('   - GET  /api/health');
-      console.log('   - GET  /api/packages/refresh');
-      console.log('   - GET  /api/packages');
-      console.log('   - GET  /api/packages/:name');
-      console.log('   - PUT  /api/packages/update-config');
-      console.log('   - GET  /api/commits/:packagePath');
-      console.log('   - GET  /api/health/packages');
-      console.log('   - PUT  /api/config/files/:id');
-      console.log('   - GET  /api/config/files');
+      console.log(SUCCESS_SERVER_START(host, validatedPort));
+      AppLogger.info('API endpoints available:', {
+        endpoints: [
+          'GET  /api/health',
+          'GET  /api/packages/refresh',
+          'GET  /api/packages',
+          'GET  /api/packages/:name',
+          'PUT  /api/packages/update-config',
+          'GET  /api/commits/:packagePath',
+          'GET  /api/health/packages',
+          'PUT  /api/config/files/:id',
+          'GET  /api/config/files',
+        ],
+      });
     });
 
     server.on('error', (err: NodeJS.ErrnoException) => {
       if (err.code === 'EADDRINUSE') {
-        console.error(
-          `Error: Port ${validatedPort} is already in use. Please specify a different port.`
-        );
+        AppLogger.error(ERROR_PORT_IN_USE(validatedPort), err);
         process.exit(1);
       } else if (err.code === 'EACCES') {
-        console.error(
-          `Error: Permission denied to listen on port ${validatedPort}. Use a port above 1024.`
-        );
+        AppLogger.error(ERROR_PERMISSION_DENIED(validatedPort), err);
         process.exit(1);
       } else {
-        console.error('Server failed to start:', err.message);
+        AppLogger.error('Server failed to start:', err);
         process.exit(1);
       }
     });
 
     // Graceful shutdown
     process.on('SIGTERM', () => {
-      console.log('SIGTERM signal received: closing HTTP server');
+      AppLogger.info(MESSAGE_GRACEFUL_SHUTDOWN);
       server.close(() => {
-        console.log('HTTP server closed');
+        AppLogger.info(MESSAGE_SERVER_CLOSED);
         process.exit(0);
       });
     });
   } catch (error: unknown) {
     const err = error as Error & { message?: string };
-    console.error('Failed to start server:', err?.message || String(error));
+    AppLogger.error('Failed to start server:', err);
     process.exit(1);
   }
 }

package/src/middleware/swagger-middleware.ts

@@ -0,0 +1,57 @@
+/**
+ * Swagger Documentation Middleware
+ * Sets up Swagger UI for API documentation
+ */
+
+import swaggerUi from 'swagger-ui-express';
+import swaggerJsDoc from 'swagger-jsdoc';
+import type { Express, Request, Response } from 'express';
+import { swaggerOptions } from '../config/swagger-config';
+
+/**
+ * Setup Swagger documentation endpoint
+ * @param app Express application instance
+ */
+export function setupSwaggerDocs(app: Express): void {
+  try {
+    const specs = swaggerJsDoc(swaggerOptions) as Record<string, unknown>;
+
+    // Serve raw Swagger JSON FIRST (before the middleware catches all /api-docs paths)
+    app.get('/api-docs/swagger.json', (_req: Request, res: Response) => {
+      res.setHeader('Content-Type', 'application/json');
+      res.send(specs);
+    });
+
+    // Serve Swagger UI at /api-docs
+    app.use(
+      '/api-docs',
+      swaggerUi.serve,
+      swaggerUi.setup(specs, {
+        swaggerOptions: {
+          url: '/api-docs/swagger.json',
+          persistAuthorization: true,
+          displayOperationId: true,
+          filter: true,
+          showExtensions: true,
+        },
+        customCss: `
+          .swagger-ui .topbar {
+            background-color: #2c3e50;
+          }
+          .swagger-ui .info .title {
+            color: #2c3e50;
+            font-weight: bold;
+          }
+          .swagger-ui .btn-box .btn {
+            background-color: #2c3e50;
+          }
+        `,
+        customCssUrl: 'https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui.min.css',
+      })
+    );
+
+    console.log('Swagger documentation available at /api-docs');
+  } catch (error) {
+    console.error('Failed to setup Swagger documentation:', error);
+  }
+}

package/src/routes/health-routes.ts

@@ -5,7 +5,7 @@ const healthRouter = express.Router();
 
 healthRouter
   .route('/refresh')
-  .get(refreshHealth);
+  .post(refreshHealth);
 
 healthRouter
   .route('/packages')

package/src/routes/package-routes.ts

@@ -5,7 +5,7 @@ const packageRouter = express.Router();
 
 packageRouter
   .route('/refresh')
-  .get(refreshPackages);
+  .post(refreshPackages);
 
 packageRouter
   .route('/update-config')

package/src/serve.ts

@@ -12,10 +12,26 @@
 import { startServer, serveDashboard } from './index';
 import { findMonorepoRoot } from './utils/utilities';
 
-const rootPath = findMonorepoRoot();
+let logLevel = '';
+let nodeEnv = 'production';
+
+const args = process.argv;
+
+if (args.includes('--dev')) {
+  nodeEnv = 'development';
+}
 
-console.log(`Starting Monodog API server...`);
-console.log(`Analyzing monorepo at root: ${rootPath}`);
+// Priority: Check for debug first, then fall back to info
+if (args.includes('--debug')) {
+  logLevel = 'debug';
+} else if (args.includes('--info')) {
+  logLevel = 'info';
+}
+
+process.env.LOG_LEVEL = logLevel;
+process.env.NODE_ENV = nodeEnv
+
+const rootPath = findMonorepoRoot();
 
 // Start the Express server and dashboard