@manojkmfsi/monodog 1.0.23 → 1.0.24

package/src/middleware/server-startup.ts

@@ -0,0 +1,140 @@
+/**
+ * Server startup logic for the API backend
+ */
+
+import express from 'express';
+import { json } from 'body-parser';
+import type { Express } from 'express';
+
+import { appConfig } from '../config-loader';
+import {
+  errorHandler,
+  notFoundHandler,
+  requestLogger,
+} from './error-handler';
+import {
+  createHelmetMiddleware,
+  createApiCorsMiddleware,
+  createTimeoutMiddleware,
+  buildApiUrl,
+  buildDashboardUrl,
+} from './security';
+
+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;
+
+/**
+ * Validate port number
+ */
+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}`);
+  }
+
+  return portNum;
+}
+
+/**
+ * Create Express app with middleware configuration
+ */
+function createApp(rootPath: string): Express {
+  const app = express();
+
+  // Timeout middleware
+  app.use(createTimeoutMiddleware());
+
+  // Store root path for routes
+  app.locals.rootPath = rootPath;
+
+  // Security and CORS setup
+  const dashboardUrl = buildDashboardUrl(appConfig);
+  const apiUrl = buildApiUrl(appConfig.server.host, appConfig.server.port);
+
+  app.use(createHelmetMiddleware(apiUrl));
+  app.use(createApiCorsMiddleware(dashboardUrl));
+
+  // Body parser
+  app.use(json({ limit: '1mb' }));
+
+  // Request logging
+  app.use(requestLogger);
+
+  // Routes
+  app.use('/api/packages', packageRouter);
+  app.use('/api/commits/', commitRouter);
+  app.use('/api/health/', healthRouter);
+  app.use('/api/config/', configRouter);
+
+  // 404 handler
+  app.use('*', notFoundHandler);
+
+  // Global error handler (must be last)
+  app.use(errorHandler);
+
+  return app;
+}
+
+/**
+ * Start the API server
+ */
+export function startServer(rootPath: string): void {
+  try {
+    const port = appConfig.server.port;
+    const host = 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: NodeJS.ErrnoException) => {
+      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: unknown) {
+    const err = error as Error & { message?: string };
+    console.error('Failed to start server:', err?.message || String(error));
+    process.exit(1);
+  }
+}

package/src/repositories/commit-repository.ts

@@ -0,0 +1,107 @@
+import { getPrismaClient, getPrismaErrors } from './prisma-client';
+import type { Commit } from '../types';
+
+const prisma = getPrismaClient();
+const Prisma = getPrismaErrors();
+
+/**
+ * Commit Repository - Handles all Commit-related database operations
+ */
+export class CommitRepository {
+  /**
+   * Find all commits for a package
+   */
+  static async findByPackageName(packageName: string) {
+    return await prisma.commit.findMany({
+      where: { packageName },
+    });
+  }
+
+  /**
+   * Find a specific commit
+   */
+  static async findByHash(hash: string, packageName: string) {
+    return await prisma.commit.findUnique({
+      where: {
+        hash_packageName: {
+          hash,
+          packageName,
+        },
+      },
+    });
+  }
+
+  /**
+   * Create or update a commit
+   */
+  static async upsert(data: {
+    hash: string;
+    message?: string;
+    author?: string;
+    date?: string | Date;
+    type?: string;
+    packageName: string;
+  }) {
+    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 as Error & { code?: string };
+      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: string, commits: Commit[]) {
+    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: string) {
+    return await prisma.commit.deleteMany({
+      where: { packageName },
+    });
+  }
+}

package/src/repositories/dependency-repository.ts

@@ -0,0 +1,109 @@
+import { getPrismaClient, getPrismaErrors } from './prisma-client';
+import type { DependencyInfo } from '../types';
+
+const prisma = getPrismaClient();
+const Prisma = getPrismaErrors();
+
+/**
+ * Dependency Repository - Handles all DependencyInfo-related database operations
+ */
+export class DependencyRepository {
+  /**
+   * Find all dependencies for a package
+   */
+  static async findByPackageName(packageName: string) {
+    return await prisma.dependencyInfo.findMany({
+      where: { packageName },
+    });
+  }
+
+  /**
+   * Find a specific dependency
+   */
+  static async findByNameAndPackage(name: string, packageName: string) {
+    return await prisma.dependencyInfo.findUnique({
+      where: {
+        name_packageName: {
+          name,
+          packageName,
+        },
+      },
+    });
+  }
+
+  /**
+   * Create or update a dependency
+   */
+  static async upsert(data: {
+    name: string;
+    version: string;
+    type: string;
+    latest?: string;
+    outdated?: boolean;
+    packageName: string;
+  }) {
+    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 as Error & { code?: string };
+      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: string, dependencies: DependencyInfo[]) {
+    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: string) {
+    return await prisma.dependencyInfo.deleteMany({
+      where: { packageName },
+    });
+  }
+}

package/src/repositories/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Repository Pattern Index
+ * Exports all repositories for data access layer
+ */
+
+export { PackageRepository } from './package-repository';
+export { PackageHealthRepository } from './package-health-repository';
+export { CommitRepository } from './commit-repository';
+export { DependencyRepository } from './dependency-repository';
+export { getPrismaClient, getPrismaErrors } from './prisma-client';

package/src/repositories/package-health-repository.ts

@@ -0,0 +1,75 @@
+import { getPrismaClient } from './prisma-client';
+
+const prisma = getPrismaClient();
+
+/**
+ * Package Health Repository - Handles all PackageHealth-related database operations
+ */
+export 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: string) {
+    return await prisma.packageHealth.findUnique({
+      where: { packageName },
+    });
+  }
+
+  /**
+   * Create or update package health record
+   */
+  static async upsert(data: {
+    packageName: string;
+    packageOverallScore: number;
+    packageBuildStatus: string;
+    packageTestCoverage: number;
+    packageLintStatus: string;
+    packageSecurity: string;
+    packageDependencies?: string;
+  }) {
+    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: string) {
+    return await prisma.packageHealth.delete({
+      where: { packageName },
+    });
+  }
+
+  /**
+   * Delete all package health records
+   */
+  static async deleteAll() {
+    return await prisma.packageHealth.deleteMany();
+  }
+}

package/src/repositories/package-repository.ts

@@ -0,0 +1,142 @@
+import { getPrismaClient } from './prisma-client';
+import type { PackageInfo } from '../types';
+
+const prisma = getPrismaClient();
+
+/**
+ * Package Repository - Handles all Package-related database operations
+ */
+export class PackageRepository {
+  /**
+   * Find all packages
+   */
+  static async findAll() {
+    return await prisma.package.findMany();
+  }
+
+  /**
+   * Find a package by name
+   */
+  static async findByName(name: string) {
+    return await prisma.package.findUnique({
+      where: { name },
+    });
+  }
+
+  /**
+   * Find a package with related data
+   */
+  static async findByNameWithRelations(name: string) {
+    return await prisma.package.findUnique({
+      where: { name },
+      include: {
+        dependenciesInfo: true,
+        commits: true,
+        packageHealth: true,
+      },
+    });
+  }
+
+  /**
+   * Create or update a package
+   */
+  static async upsert(data: {
+    name: string;
+    version?: string;
+    type?: string;
+    path?: string;
+    description?: string;
+    license?: string;
+    repository?: Record<string, unknown>;
+    scripts?: Record<string, unknown>;
+    dependencies?: Record<string, unknown>;
+    devDependencies?: Record<string, unknown>;
+    peerDependencies?: Record<string, unknown>;
+    maintainers?: string;
+    status?: string;
+  }) {
+    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: string, status: string) {
+    return await prisma.package.update({
+      where: { name },
+      data: { status },
+    });
+  }
+
+  /**
+   * Update package configuration
+   */
+  static async updateConfig(name: string, updateData: Record<string, unknown>) {
+    const data: Record<string, unknown> = {
+      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: string) {
+    return await prisma.package.delete({
+      where: { name },
+    });
+  }
+}

package/src/repositories/prisma-client.ts

@@ -0,0 +1,25 @@
+import * as PrismaPkg from '@prisma/client';
+
+const PrismaClient = (PrismaPkg as any).PrismaClient || (PrismaPkg as any).default || PrismaPkg;
+const Prisma = (PrismaPkg as any).Prisma || (PrismaPkg as any).PrismaClient?.Prisma || (PrismaPkg as any).default?.Prisma || PrismaPkg;
+
+let prismaInstance: ReturnType<typeof PrismaClient> | null = null;
+
+/**
+ * Get singleton instance of Prisma Client
+ */
+export function getPrismaClient() {
+  if (!prismaInstance) {
+    prismaInstance = new PrismaClient();
+  }
+  return prismaInstance;
+}
+
+/**
+ * Get Prisma error classes for error handling
+ */
+export function getPrismaErrors() {
+  return Prisma;
+}
+
+export default getPrismaClient;

package/src/routes/{commitRoutes.ts → commit-routes.ts}

@@ -1,5 +1,5 @@
 import express from 'express';
-import { getCommitsByPath } from '../controllers/commitController';
+import { getCommitsByPath } from '../controllers/commit-controller';
 
 const commitRouter = express.Router();
 

package/src/routes/{configRoutes.ts → config-routes.ts}

@@ -1,5 +1,5 @@
 import express from 'express';
-import { getConfigurationFiles, updateConfigFile } from '../controllers/configController';
+import { getConfigurationFiles, updateConfigFile } from '../controllers/config-controller';
 
 const configRouter = express.Router();
 

package/src/routes/{healthRoutes.ts → health-routes.ts}

@@ -1,5 +1,5 @@
 import express from 'express';
-import { getPackagesHealth, refreshHealth } from '../controllers/healthController';
+import { getPackagesHealth, refreshHealth } from '../controllers/health-controller';
 
 const healthRouter = express.Router();
 

package/src/routes/{packageRoutes.ts → package-routes.ts}

@@ -1,5 +1,5 @@
 import express from 'express';
-import { getPackages, refreshPackages, getPackageDetail, updatePackageConfig } from '../controllers/packageController';
+import { getPackages, refreshPackages, getPackageDetail, updatePackageConfig } from '../controllers/package-controller';
 
 const packageRouter = express.Router();
 

package/src/services/{commitService.ts → commit-service.ts}

@@ -1,4 +1,4 @@
-import { GitService } from './gitService';
+import { GitService } from './git-service';
 import path from 'path';
 import fs from 'fs';