@manojkmfsi/monodog 1.0.25 → 1.1.0

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
@@ -30,8 +39,8 @@ export function createApiCorsMiddleware(dashboardUrl: string) {
   const corsOptions: CorsOptions = {
     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  `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

@@ -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,11 +70,14 @@ 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);
 
+  // Setup Swagger documentation
+  setupSwaggerDocs(app);
+
   // Routes
   app.use('/api/packages', packageRouter);
   app.use('/api/commits/', commitRouter);
@@ -97,7 +108,7 @@ export function startServer(rootPath: string): void {
     const app = createApp(rootPath);
 
     const server = app.listen(validatedPort, host, () => {
-      console.log(`Backend server listening on http://${host}:${validatedPort}`);
+      console.log(SUCCESS_SERVER_START(host, validatedPort));
       AppLogger.info('API endpoints available:', {
         endpoints: [
           'GET  /api/health',
@@ -115,10 +126,10 @@ export function startServer(rootPath: string): void {
 
     server.on('error', (err: NodeJS.ErrnoException) => {
       if (err.code === 'EADDRINUSE') {
-        AppLogger.error(`Port ${validatedPort} is already in use. Please specify a different port.`, err);
+        AppLogger.error(ERROR_PORT_IN_USE(validatedPort), err);
         process.exit(1);
       } else if (err.code === 'EACCES') {
-        AppLogger.error(`Permission denied to listen on port ${validatedPort}. Use a port above 1024.`, err);
+        AppLogger.error(ERROR_PERMISSION_DENIED(validatedPort), err);
         process.exit(1);
       } else {
         AppLogger.error('Server failed to start:', err);
@@ -128,9 +139,9 @@ export function startServer(rootPath: string): void {
 
     // Graceful shutdown
     process.on('SIGTERM', () => {
-      AppLogger.info('SIGTERM signal received: closing HTTP server');
+      AppLogger.info(MESSAGE_GRACEFUL_SHUTDOWN);
       server.close(() => {
-        AppLogger.info('HTTP server closed');
+        AppLogger.info(MESSAGE_SERVER_CLOSED);
         process.exit(0);
       });
     });

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/services/health-service.ts

@@ -12,6 +12,9 @@ import {
 import { PackageHealthRepository, PackageRepository } from '../repositories';
 import type { TransformedPackageHealth, HealthResponse, PackageHealthModel } from '../types/database';
 
+// Track in-flight health refresh requests to prevent duplicates
+let inFlightHealthRefresh: Promise<HealthResponse> | null = null;
+
 export const getHealthSummaryService = async (): Promise<HealthResponse> => {
   const packageHealthData = await PackageHealthRepository.findAll() as PackageHealthModel[];
   console.log('packageHealthData -->', packageHealthData.length);
@@ -55,83 +58,104 @@ export const getHealthSummaryService = async (): Promise<HealthResponse> => {
 }
 
 export const healthRefreshService = async (rootDir: string) => {
-  const packages = scanMonorepo(rootDir);
-  console.log('packages -->', packages.length);
-  const healthMetrics = await Promise.all(
-    packages.map(async pkg => {
-      try {
-        // Await each health check function since they return promises
-        const buildStatus = await funCheckBuildStatus(pkg);
-        const testCoverage = 0; //await funCheckTestCoverage(pkg); // skip test coverage for now
-        const lintStatus = await funCheckLintStatus(pkg);
-        const securityAudit = await funCheckSecurityAudit(pkg);
-        // Calculate overall health score
-        const overallScore = calculatePackageHealth(
-          buildStatus,
-          testCoverage,
-          lintStatus,
-          securityAudit
-        );
-
-        const health = {
-          buildStatus: buildStatus,
-          testCoverage: testCoverage,
-          lintStatus: lintStatus,
-          securityAudit: securityAudit,
-          overallScore: overallScore.overallScore,
-        };
-        const packageStatus =
-          health.overallScore >= 80
-            ? 'healthy'
-            : health.overallScore >= 60 && health.overallScore < 80
-              ? 'warning'
-              : 'error';
-
-        console.log(pkg.name, '-->', health, packageStatus);
-
-        await PackageHealthRepository.upsert({
-          packageName: pkg.name,
-          packageOverallScore: overallScore.overallScore,
-          packageBuildStatus: buildStatus,
-          packageTestCoverage: testCoverage,
-          packageLintStatus: lintStatus,
-          packageSecurity: securityAudit,
-          packageDependencies: '',
-        });
-        // update related package status as well
-        await PackageRepository.updateStatus(pkg.name, packageStatus);
-        return {
-          packageName: pkg.name,
-          health,
-          isHealthy: health.overallScore >= 80,
-        };
-      } catch (error) {
-        return {
-          packageName: pkg.name,
-          health: {
-            "buildStatus": "",
-            "testCoverage": 0,
-            "lintStatus": "",
-            "securityAudit": "",
-            "overallScore": 0
-          },
-          isHealthy: false,
-          error: 'Failed to fetch health metrics1',
-        };
-      }
-    })
-  );
-  return {
-    packages: healthMetrics.filter(h => !h.error),
-    summary: {
-      total: packages.length,
-      healthy: healthMetrics.filter(h => h.isHealthy).length,
-      unhealthy: healthMetrics.filter(h => !h.isHealthy).length,
-      averageScore:
-        healthMetrics
-          .filter(h => h.health)
-          .reduce((sum, h) => sum + h.health!.overallScore, 0) /
-        healthMetrics.filter(h => h.health).length,
-    },
-  };
+  // If a health refresh is already in progress, return the in-flight promise
+  if (inFlightHealthRefresh) {
+    console.log('Health refresh already in progress, returning cached promise');
+    return inFlightHealthRefresh;
+  }
+
+  // Create and store the health refresh promise
+  inFlightHealthRefresh = (async () => {
+    try {
+      const packages = scanMonorepo(rootDir);
+      console.log('packages -->', packages.length);
+      const healthMetrics = await Promise.all(
+        packages.map(async pkg => {
+          try {
+            // Await each health check function since they return promises
+            const buildStatus = await funCheckBuildStatus(pkg);
+            const testCoverage = 0; //await funCheckTestCoverage(pkg); // skip test coverage for now
+            const lintStatus = await funCheckLintStatus(pkg);
+            const securityAudit = await funCheckSecurityAudit(pkg);
+            // Calculate overall health score
+            const overallScore = calculatePackageHealth(
+              buildStatus,
+              testCoverage,
+              lintStatus,
+              securityAudit
+            );
+
+            const health = {
+              buildStatus: buildStatus,
+              testCoverage: testCoverage,
+              lintStatus: lintStatus,
+              securityAudit: securityAudit,
+              overallScore: overallScore.overallScore,
+            };
+            const packageStatus =
+              health.overallScore >= 80
+                ? 'healthy'
+                : health.overallScore >= 60 && health.overallScore < 80
+                  ? 'warning'
+                  : 'error';
+
+            console.log(pkg.name, '-->', health, packageStatus);
+
+            await PackageHealthRepository.upsert({
+              packageName: pkg.name,
+              packageOverallScore: overallScore.overallScore,
+              packageBuildStatus: buildStatus,
+              packageTestCoverage: testCoverage,
+              packageLintStatus: lintStatus,
+              packageSecurity: securityAudit,
+              packageDependencies: '',
+            });
+            // update related package status as well
+            await PackageRepository.updateStatus(pkg.name, packageStatus);
+            return {
+              packageName: pkg.name,
+              health,
+              isHealthy: health.overallScore >= 80,
+            };
+          } catch (error) {
+            return {
+              packageName: pkg.name,
+              health: {
+                "buildStatus": "",
+                "testCoverage": 0,
+                "lintStatus": "",
+                "securityAudit": "",
+                "overallScore": 0
+              },
+              isHealthy: false,
+              error: 'Failed to fetch health metrics1',
+            };
+          }
+        })
+      );
+
+      const result: HealthResponse = {
+        packages: healthMetrics.filter(h => !h.error),
+        summary: {
+          total: packages.length,
+          healthy: healthMetrics.filter(h => h.isHealthy).length,
+          unhealthy: healthMetrics.filter(h => !h.isHealthy).length,
+          averageScore:
+            healthMetrics.filter(h => h.health).length > 0
+              ? healthMetrics
+                  .filter(h => h.health)
+                  .reduce((sum, h) => sum + h.health!.overallScore, 0) /
+                healthMetrics.filter(h => h.health).length
+              : 0,
+        },
+      };
+
+      return result;
+    } finally {
+      // Clear the in-flight promise after completion
+      inFlightHealthRefresh = null;
+    }
+  })();
+
+  return inFlightHealthRefresh;
 }

package/src/services/package-service.ts

@@ -160,7 +160,33 @@ export const refreshPackagesService = async (rootPath: string) => {
     await storePackage(pkg);
   }
 
-  return packages;
+  // Return transformed packages like getPackagesService
+  const dbPackages = await PackageRepository.findAll();
+  const transformedPackages = dbPackages.map((pkg: PackageModel) => {
+    const transformedPkg = { ...pkg };
+
+    transformedPkg.maintainers = pkg.maintainers
+      ? JSON.parse(pkg.maintainers)
+      : [];
+
+    transformedPkg.scripts = pkg.scripts ? JSON.parse(pkg.scripts) : {};
+    transformedPkg.repository = pkg.repository
+      ? JSON.parse(pkg.repository)
+      : {};
+
+    transformedPkg.dependencies = pkg.dependencies
+      ? JSON.parse(pkg.dependencies)
+      : [];
+    transformedPkg.devDependencies = pkg.devDependencies
+      ? JSON.parse(pkg.devDependencies)
+      : [];
+    transformedPkg.peerDependencies = pkg.peerDependencies
+      ? JSON.parse(pkg.peerDependencies)
+      : [];
+    return transformedPkg;
+  });
+
+  return transformedPackages;
 }
 
 export const getPackageDetailService = async (name: string) => {

package/src/types/swagger-jsdoc.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type declarations for swagger-jsdoc
+ * Provides TypeScript support for swagger-jsdoc module
+ */
+
+declare module 'swagger-jsdoc' {
+  interface SwaggerOptions {
+    definition?: Record<string, unknown>;
+    apis?: string[];
+  }
+
+  function swaggerJsDoc(options: SwaggerOptions): Record<string, unknown>;
+
+  export = swaggerJsDoc;
+}