@manojkmfsi/monodog 1.0.23 → 1.0.25

package/dist/middleware/security.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Security middleware and configuration
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHelmetMiddleware = createHelmetMiddleware;
+exports.createApiCorsMiddleware = createApiCorsMiddleware;
+exports.createDashboardCorsMiddleware = createDashboardCorsMiddleware;
+exports.createTimeoutMiddleware = createTimeoutMiddleware;
+exports.buildApiUrl = buildApiUrl;
+exports.buildDashboardUrl = buildDashboardUrl;
+const helmet_1 = __importDefault(require("helmet"));
+const cors_1 = __importDefault(require("cors"));
+/**
+ * Create Helmet security middleware with Content Security Policy
+ */
+function createHelmetMiddleware(apiUrl) {
+    return (0, helmet_1.default)({
+        contentSecurityPolicy: {
+            directives: {
+                defaultSrc: ["'self'"],
+                connectSrc: ["'self'", apiUrl, 'http://localhost:*', 'http://127.0.0.1:*'],
+                scriptSrc: ["'self'"],
+                imgSrc: ["'self'", 'data:', 'https:'],
+            },
+        },
+    });
+}
+/**
+ * Create CORS middleware for API server
+ */
+function createApiCorsMiddleware(dashboardUrl) {
+    const corsOptions = {
+        origin: dashboardUrl,
+        credentials: true,
+        methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization'],
+    };
+    return (0, cors_1.default)(corsOptions);
+}
+/**
+ * Create CORS middleware for dashboard (no cross-origin)
+ */
+function createDashboardCorsMiddleware() {
+    const corsOptions = {
+        origin: false, // Don't allow any origin for static assets
+    };
+    return (0, cors_1.default)(corsOptions);
+}
+/**
+ * Request timeout middleware (30 seconds)
+ */
+function createTimeoutMiddleware() {
+    return (req, res, next) => {
+        req.setTimeout(30000);
+        res.setTimeout(30000);
+        next();
+    };
+}
+/**
+ * Build API URL based on config
+ */
+function buildApiUrl(host, port) {
+    const apiHost = host === '0.0.0.0' ? 'localhost' : host;
+    return `http://${apiHost}:${port}`;
+}
+/**
+ * Build dashboard URL based on config
+ */
+function buildDashboardUrl(config) {
+    const dashboardHost = config.dashboard.host === '0.0.0.0'
+        ? 'localhost'
+        : config.dashboard.host;
+    return `http://${dashboardHost}:${config.dashboard.port}`;
+}

package/dist/middleware/server-startup.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Server startup logic for the API backend
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const express_1 = __importDefault(require("express"));
+const body_parser_1 = require("body-parser");
+const logger_1 = require("./logger");
+const config_loader_1 = require("../config-loader");
+const error_handler_1 = require("./error-handler");
+const security_1 = require("./security");
+const package_routes_1 = __importDefault(require("../routes/package-routes"));
+const commit_routes_1 = __importDefault(require("../routes/commit-routes"));
+const health_routes_1 = __importDefault(require("../routes/health-routes"));
+const config_routes_1 = __importDefault(require("../routes/config-routes"));
+// Security constants
+const PORT_MIN = 1024;
+const PORT_MAX = 65535;
+/**
+ * Validate port number
+ */
+function validatePort(port) {
+    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}`);
+    }
+    return portNum;
+}
+/**
+ * Create Express app with middleware configuration
+ */
+function createApp(rootPath) {
+    const app = (0, express_1.default)();
+    // Timeout middleware
+    app.use((0, security_1.createTimeoutMiddleware)());
+    // Store root path for routes
+    app.locals.rootPath = rootPath;
+    // Security and CORS setup
+    const dashboardUrl = (0, security_1.buildDashboardUrl)(config_loader_1.appConfig);
+    const apiUrl = (0, security_1.buildApiUrl)(config_loader_1.appConfig.server.host, config_loader_1.appConfig.server.port);
+    app.use((0, security_1.createHelmetMiddleware)(apiUrl));
+    app.use((0, security_1.createApiCorsMiddleware)(dashboardUrl));
+    // Body parser
+    app.use((0, body_parser_1.json)({ limit: '1mb' }));
+    // HTTP request logging with Morgan
+    app.use(logger_1.httpLogger);
+    // Routes
+    app.use('/api/packages', package_routes_1.default);
+    app.use('/api/commits/', commit_routes_1.default);
+    app.use('/api/health/', health_routes_1.default);
+    app.use('/api/config/', config_routes_1.default);
+    // 404 handler
+    app.use('*', error_handler_1.notFoundHandler);
+    // Global error handler (must be last)
+    app.use(error_handler_1.errorHandler);
+    return app;
+}
+/**
+ * Start the API server
+ */
+function startServer(rootPath) {
+    try {
+        const port = config_loader_1.appConfig.server.port;
+        const host = config_loader_1.appConfig.server.host;
+        const validatedPort = validatePort(port);
+        logger_1.AppLogger.info(`Starting Monodog API server...`);
+        logger_1.AppLogger.info(`Analyzing monorepo at root: ${rootPath}`);
+        const app = createApp(rootPath);
+        const server = app.listen(validatedPort, host, () => {
+            console.log(`Backend server listening on http://${host}:${validatedPort}`);
+            logger_1.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) => {
+            if (err.code === 'EADDRINUSE') {
+                logger_1.AppLogger.error(`Port ${validatedPort} is already in use. Please specify a different port.`, err);
+                process.exit(1);
+            }
+            else if (err.code === 'EACCES') {
+                logger_1.AppLogger.error(`Permission denied to listen on port ${validatedPort}. Use a port above 1024.`, err);
+                process.exit(1);
+            }
+            else {
+                logger_1.AppLogger.error('Server failed to start:', err);
+                process.exit(1);
+            }
+        });
+        // Graceful shutdown
+        process.on('SIGTERM', () => {
+            logger_1.AppLogger.info('SIGTERM signal received: closing HTTP server');
+            server.close(() => {
+                logger_1.AppLogger.info('HTTP server closed');
+                process.exit(0);
+            });
+        });
+    }
+    catch (error) {
+        const err = error;
+        logger_1.AppLogger.error('Failed to start server:', err);
+        process.exit(1);
+    }
+}

package/dist/repositories/commit-repository.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitRepository = void 0;
+const prisma_client_1 = require("./prisma-client");
+const prisma = (0, prisma_client_1.getPrismaClient)();
+const Prisma = (0, prisma_client_1.getPrismaErrors)();
+/**
+ * Commit Repository - Handles all Commit-related database operations
+ */
+class CommitRepository {
+    /**
+     * Find all commits for a package
+     */
+    static async findByPackageName(packageName) {
+        return await prisma.commit.findMany({
+            where: { packageName },
+        });
+    }
+    /**
+     * Find a specific commit
+     */
+    static async findByHash(hash, packageName) {
+        return await prisma.commit.findUnique({
+            where: {
+                hash_packageName: {
+                    hash,
+                    packageName,
+                },
+            },
+        });
+    }
+    /**
+     * Create or update a commit
+     */
+    static async upsert(data) {
+        try {
+            return await prisma.commit.upsert({
+                where: {
+                    hash_packageName: {
+                        hash: data.hash,
+                        packageName: data.packageName,
+                    },
+                },
+                update: {
+                    message: data.message || '',
+                    author: data.author || '',
+                    date: data.date,
+                    type: data.type || '',
+                },
+                create: {
+                    hash: data.hash,
+                    message: data.message || '',
+                    author: data.author || '',
+                    date: data.date,
+                    type: data.type || '',
+                    packageName: data.packageName,
+                },
+            });
+        }
+        catch (e) {
+            const err = e;
+            if (err instanceof Prisma.PrismaClientKnownRequestError &&
+                err.code === 'P2002') {
+                console.warn(`Skipping commit: ${data.hash} (Commit already exists)`);
+            }
+            else {
+                console.error(`Failed to store commit: ${data.hash}`, err);
+                throw err;
+            }
+        }
+    }
+    /**
+     * Store multiple commits
+     */
+    static async storeMany(packageName, commits) {
+        console.log('Storing commits for: ' + packageName);
+        for (const commit of commits) {
+            await this.upsert({
+                hash: commit.hash,
+                message: commit.message,
+                author: commit.author,
+                date: commit.date,
+                type: commit.type,
+                packageName,
+            });
+        }
+    }
+    /**
+     * Delete all commits for a package
+     */
+    static async deleteByPackageName(packageName) {
+        return await prisma.commit.deleteMany({
+            where: { packageName },
+        });
+    }
+}
+exports.CommitRepository = CommitRepository;

package/dist/repositories/dependency-repository.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyRepository = void 0;
+const prisma_client_1 = require("./prisma-client");
+const prisma = (0, prisma_client_1.getPrismaClient)();
+const Prisma = (0, prisma_client_1.getPrismaErrors)();
+/**
+ * Dependency Repository - Handles all DependencyInfo-related database operations
+ */
+class DependencyRepository {
+    /**
+     * Find all dependencies for a package
+     */
+    static async findByPackageName(packageName) {
+        return await prisma.dependencyInfo.findMany({
+            where: { packageName },
+        });
+    }
+    /**
+     * Find a specific dependency
+     */
+    static async findByNameAndPackage(name, packageName) {
+        return await prisma.dependencyInfo.findUnique({
+            where: {
+                name_packageName: {
+                    name,
+                    packageName,
+                },
+            },
+        });
+    }
+    /**
+     * Create or update a dependency
+     */
+    static async upsert(data) {
+        try {
+            return await prisma.dependencyInfo.upsert({
+                where: {
+                    name_packageName: {
+                        name: data.name,
+                        packageName: data.packageName,
+                    },
+                },
+                update: {
+                    version: data.version,
+                    type: data.type,
+                    latest: data.latest || '',
+                    outdated: data.outdated ?? false,
+                },
+                create: {
+                    name: data.name,
+                    version: data.version,
+                    type: data.type,
+                    latest: data.latest || '',
+                    outdated: data.outdated ?? false,
+                    packageName: data.packageName,
+                },
+            });
+        }
+        catch (e) {
+            const err = e;
+            if (err instanceof Prisma.PrismaClientKnownRequestError &&
+                err.code === 'P2002') {
+                console.warn(`Skipping dependency: ${data.name} (Dependency already exists)`);
+            }
+            else {
+                console.error(`Failed to store dependency: ${data.name}`, err);
+                throw err;
+            }
+        }
+    }
+    /**
+     * Store multiple dependencies
+     */
+    static async storeMany(packageName, dependencies) {
+        console.log('Storing Dependencies for: ' + packageName);
+        for (const dep of dependencies) {
+            await this.upsert({
+                name: dep.name,
+                version: dep.version,
+                type: dep.type,
+                latest: dep.latest,
+                outdated: dep.outdated,
+                packageName,
+            });
+        }
+    }
+    /**
+     * Delete all dependencies for a package
+     */
+    static async deleteByPackageName(packageName) {
+        return await prisma.dependencyInfo.deleteMany({
+            where: { packageName },
+        });
+    }
+}
+exports.DependencyRepository = DependencyRepository;

package/dist/repositories/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Repository Pattern Index
+ * Exports all repositories for data access layer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaErrors = exports.getPrismaClient = exports.DependencyRepository = exports.CommitRepository = exports.PackageHealthRepository = exports.PackageRepository = void 0;
+var package_repository_1 = require("./package-repository");
+Object.defineProperty(exports, "PackageRepository", { enumerable: true, get: function () { return package_repository_1.PackageRepository; } });
+var package_health_repository_1 = require("./package-health-repository");
+Object.defineProperty(exports, "PackageHealthRepository", { enumerable: true, get: function () { return package_health_repository_1.PackageHealthRepository; } });
+var commit_repository_1 = require("./commit-repository");
+Object.defineProperty(exports, "CommitRepository", { enumerable: true, get: function () { return commit_repository_1.CommitRepository; } });
+var dependency_repository_1 = require("./dependency-repository");
+Object.defineProperty(exports, "DependencyRepository", { enumerable: true, get: function () { return dependency_repository_1.DependencyRepository; } });
+var prisma_client_1 = require("./prisma-client");
+Object.defineProperty(exports, "getPrismaClient", { enumerable: true, get: function () { return prisma_client_1.getPrismaClient; } });
+Object.defineProperty(exports, "getPrismaErrors", { enumerable: true, get: function () { return prisma_client_1.getPrismaErrors; } });

package/dist/repositories/package-health-repository.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageHealthRepository = void 0;
+const prisma_client_1 = require("./prisma-client");
+const prisma = (0, prisma_client_1.getPrismaClient)();
+/**
+ * Package Health Repository - Handles all PackageHealth-related database operations
+ */
+class PackageHealthRepository {
+    /**
+     * Find all package health records
+     */
+    static async findAll() {
+        return await prisma.packageHealth.findMany();
+    }
+    /**
+     * Find package health by package name
+     */
+    static async findByPackageName(packageName) {
+        return await prisma.packageHealth.findUnique({
+            where: { packageName },
+        });
+    }
+    /**
+     * Create or update package health record
+     */
+    static async upsert(data) {
+        return await prisma.packageHealth.upsert({
+            where: { packageName: data.packageName },
+            update: {
+                packageOverallScore: data.packageOverallScore,
+                packageBuildStatus: data.packageBuildStatus,
+                packageTestCoverage: data.packageTestCoverage,
+                packageLintStatus: data.packageLintStatus,
+                packageSecurity: data.packageSecurity,
+                packageDependencies: data.packageDependencies || '',
+                updatedAt: new Date(),
+            },
+            create: {
+                packageName: data.packageName,
+                packageOverallScore: data.packageOverallScore,
+                packageBuildStatus: data.packageBuildStatus,
+                packageTestCoverage: data.packageTestCoverage,
+                packageLintStatus: data.packageLintStatus,
+                packageSecurity: data.packageSecurity,
+                packageDependencies: data.packageDependencies || '',
+            },
+        });
+    }
+    /**
+     * Delete package health record
+     */
+    static async deleteByPackageName(packageName) {
+        return await prisma.packageHealth.delete({
+            where: { packageName },
+        });
+    }
+    /**
+     * Delete all package health records
+     */
+    static async deleteAll() {
+        return await prisma.packageHealth.deleteMany();
+    }
+}
+exports.PackageHealthRepository = PackageHealthRepository;

package/dist/repositories/package-repository.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageRepository = void 0;
+const prisma_client_1 = require("./prisma-client");
+const prisma = (0, prisma_client_1.getPrismaClient)();
+/**
+ * Package Repository - Handles all Package-related database operations
+ */
+class PackageRepository {
+    /**
+     * Find all packages
+     */
+    static async findAll() {
+        return await prisma.package.findMany();
+    }
+    /**
+     * Find a package by name
+     */
+    static async findByName(name) {
+        return await prisma.package.findUnique({
+            where: { name },
+        });
+    }
+    /**
+     * Find a package with related data
+     */
+    static async findByNameWithRelations(name) {
+        return await prisma.package.findUnique({
+            where: { name },
+            include: {
+                dependenciesInfo: true,
+                commits: true,
+                packageHealth: true,
+            },
+        });
+    }
+    /**
+     * Create or update a package
+     */
+    static async upsert(data) {
+        const createData = {
+            createdAt: new Date(),
+            lastUpdated: new Date(),
+            dependencies: JSON.stringify(data.dependencies || {}),
+            maintainers: typeof data.maintainers === 'string' ? data.maintainers : '',
+            scripts: JSON.stringify(data.scripts || {}),
+            devDependencies: JSON.stringify(data.devDependencies || {}),
+            peerDependencies: JSON.stringify(data.peerDependencies || {}),
+            name: data.name,
+            version: data.version || '',
+            type: data.type || '',
+            path: data.path || '',
+            description: data.description || '',
+            license: data.license || '',
+            repository: JSON.stringify(data.repository || {}),
+            status: data.status || '',
+        };
+        const updateData = {
+            version: data.version,
+            type: data.type,
+            path: data.path,
+            description: data.description,
+            license: data.license,
+            repository: JSON.stringify(data.repository || {}),
+            scripts: JSON.stringify(data.scripts || {}),
+            lastUpdated: new Date(),
+        };
+        return await prisma.package.upsert({
+            where: { name: data.name },
+            create: createData,
+            update: updateData,
+        });
+    }
+    /**
+     * Update package status
+     */
+    static async updateStatus(name, status) {
+        return await prisma.package.update({
+            where: { name },
+            data: { status },
+        });
+    }
+    /**
+     * Update package configuration
+     */
+    static async updateConfig(name, updateData) {
+        const data = {
+            lastUpdated: new Date(),
+        };
+        if (updateData.version)
+            data.version = updateData.version;
+        if (updateData.description !== undefined)
+            data.description = updateData.description || '';
+        if (updateData.license !== undefined)
+            data.license = updateData.license || '';
+        if (updateData.scripts)
+            data.scripts = JSON.stringify(updateData.scripts);
+        if (updateData.repository)
+            data.repository = JSON.stringify(updateData.repository);
+        if (updateData.dependencies)
+            data.dependencies = JSON.stringify(updateData.dependencies);
+        if (updateData.devDependencies)
+            data.devDependencies = JSON.stringify(updateData.devDependencies);
+        if (updateData.peerDependencies)
+            data.peerDependencies = JSON.stringify(updateData.peerDependencies);
+        return await prisma.package.update({
+            where: { name },
+            data,
+        });
+    }
+    /**
+     * Delete all packages
+     */
+    static async deleteAll() {
+        return await prisma.package.deleteMany();
+    }
+    /**
+     * Delete a package by name
+     */
+    static async deleteByName(name) {
+        return await prisma.package.delete({
+            where: { name },
+        });
+    }
+}
+exports.PackageRepository = PackageRepository;

package/dist/repositories/prisma-client.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaClient = getPrismaClient;
+exports.getPrismaErrors = getPrismaErrors;
+const PrismaPkg = __importStar(require("@prisma/client"));
+const PrismaClient = PrismaPkg.PrismaClient || PrismaPkg.default || PrismaPkg;
+const Prisma = PrismaPkg.Prisma || PrismaPkg.PrismaClient?.Prisma || PrismaPkg.default?.Prisma || PrismaPkg;
+let prismaInstance = null;
+/**
+ * Get singleton instance of Prisma Client
+ */
+function getPrismaClient() {
+    if (!prismaInstance) {
+        prismaInstance = new PrismaClient();
+    }
+    return prismaInstance;
+}
+/**
+ * Get Prisma error classes for error handling
+ */
+function getPrismaErrors() {
+    return Prisma;
+}
+exports.default = getPrismaClient;

package/dist/routes/{commitRoutes.js → commit-routes.js}

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
-const commitController_1 = require("../controllers/commitController");
+const commit_controller_1 = require("../controllers/commit-controller");
 const commitRouter = express_1.default.Router();
 commitRouter
     .route('/:packagePath')
-    .get(commitController_1.getCommitsByPath);
+    .get(commit_controller_1.getCommitsByPath);
 exports.default = commitRouter;

package/dist/routes/{configRoutes.js → config-routes.js}

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
-const configController_1 = require("../controllers/configController");
+const config_controller_1 = require("../controllers/config-controller");
 const configRouter = express_1.default.Router();
 configRouter
     .route('/files')
-    .get(configController_1.getConfigurationFiles);
+    .get(config_controller_1.getConfigurationFiles);
 configRouter
     .route('/files/:id')
-    .put(configController_1.updateConfigFile);
+    .put(config_controller_1.updateConfigFile);
 exports.default = configRouter;