@manojkmfsi/monodog 1.0.23 → 1.0.24

package/dist/middleware/server-startup.js

@@ -0,0 +1,111 @@
+"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 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' }));
+    // Request logging
+    app.use(error_handler_1.requestLogger);
+    // 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);
+        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');
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.error(`Error: Port ${validatedPort} is already in use. Please specify a different port.`);
+                process.exit(1);
+            }
+            else if (err.code === 'EACCES') {
+                console.error(`Error: Permission denied to listen on port ${validatedPort}. Use a port above 1024.`);
+                process.exit(1);
+            }
+            else {
+                console.error('Server failed to start:', err.message);
+                process.exit(1);
+            }
+        });
+        // Graceful shutdown
+        process.on('SIGTERM', () => {
+            console.log('SIGTERM signal received: closing HTTP server');
+            server.close(() => {
+                console.log('HTTP server closed');
+                process.exit(0);
+            });
+        });
+    }
+    catch (error) {
+        const err = error;
+        console.error('Failed to start server:', err?.message || String(error));
+        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;

package/dist/routes/{healthRoutes.js → health-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 healthController_1 = require("../controllers/healthController");
+const health_controller_1 = require("../controllers/health-controller");
 const healthRouter = express_1.default.Router();
 healthRouter
     .route('/refresh')
-    .get(healthController_1.refreshHealth);
+    .get(health_controller_1.refreshHealth);
 healthRouter
     .route('/packages')
-    .get(healthController_1.getPackagesHealth);
+    .get(health_controller_1.getPackagesHealth);
 exports.default = healthRouter;

package/dist/routes/{packageRoutes.js → package-routes.js}

@@ -4,18 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
-const packageController_1 = require("../controllers/packageController");
+const package_controller_1 = require("../controllers/package-controller");
 const packageRouter = express_1.default.Router();
 packageRouter
     .route('/refresh')
-    .get(packageController_1.refreshPackages);
+    .get(package_controller_1.refreshPackages);
 packageRouter
     .route('/update-config')
-    .put(packageController_1.updatePackageConfig);
+    .put(package_controller_1.updatePackageConfig);
 packageRouter
     .route('/:name')
-    .get(packageController_1.getPackageDetail);
+    .get(package_controller_1.getPackageDetail);
 packageRouter
     .route('/')
-    .get(packageController_1.getPackages);
+    .get(package_controller_1.getPackages);
 exports.default = packageRouter;

package/dist/services/{commitService.js → commit-service.js}

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCommitsByPathService = void 0;
-const gitService_1 = require("./gitService");
+const git_service_1 = require("./git-service");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const getCommitsByPathService = async (packagePath) => {
@@ -12,7 +12,7 @@ const getCommitsByPathService = async (packagePath) => {
     const decodedPath = decodeURIComponent(packagePath);
     console.log('Fetching commits for path:', decodedPath);
     console.log('Current working directory:', process.cwd());
-    const gitService = new gitService_1.GitService();
+    const gitService = new git_service_1.GitService();
     // Check if this is an absolute path and convert to relative if needed
     let relativePath = decodedPath;
     const projectRoot = process.cwd();