@manojkmfsi/monodog 1.0.23 → 1.0.25

package/src/services/{configService.ts → config-service.ts}

@@ -1,9 +1,25 @@
 import fs from 'fs';
 import path from 'path';
 
-import * as PrismaPkg from '@prisma/client';
-const PrismaClient = (PrismaPkg as any).PrismaClient || (PrismaPkg as any).default || PrismaPkg;
-const prisma = new PrismaClient();
+import { PackageRepository } from '../repositories';
+
+/**
+ * Configuration file interface
+ */
+interface ConfigFile {
+  id: string;
+  name: string;
+  path: string;
+  type: string;
+  content: string;
+  size: number;
+  lastModified: string;
+  hasSecrets: boolean;
+}
+
+interface TransformedConfigFile extends ConfigFile {
+  isEditable: boolean;
+}
 
 // Helper function to scan for configuration files
 async function scanConfigFiles(rootDir: string): Promise<any[]> {
@@ -36,7 +52,7 @@ async function scanConfigFiles(rootDir: string): Promise<any[]> {
     'dockerfile*',
   ];
 
-  const configFiles: any[] = [];
+  const configFiles: ConfigFile[] = [];
   const scannedPaths = new Set();
 
   function scanDirectory(dir: string, depth = 0) {
@@ -325,7 +341,7 @@ export const updatePackageConfigurationService = async (packagePath: string, pac
   await fs.promises.writeFile(packageJsonPath, formattedConfig, 'utf8');
 
   // Update the package in the database - use correct field names based on your Prisma schema
-  const updateData: any = {
+  const updateData: Record<string, unknown> = {
     lastUpdated: new Date(),
   };
 
@@ -348,10 +364,7 @@ export const updatePackageConfigurationService = async (packagePath: string, pac
 
   console.log('Updating database with:', updateData);
 
-  const updatedPackage = await prisma.package.update({
-    where: { name: packageName },
-    data: updateData,
-  });
+  const updatedPackage = await PackageRepository.updateConfig(packageName, updateData);
 
   // Transform the response
   const transformedPackage = {

package/src/services/{gitService.ts → git-service.ts}

@@ -9,7 +9,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import path from 'path';
 
-import type { GitCommit } from '../types';
+import type { Commit } from '../types';
 import { VALID_COMMIT_TYPES } from '../types';
 
 // Promisify the standard 'exec' function for easy async/await usage
@@ -25,7 +25,7 @@ export class GitService {
   /**
    * Retrieves commit history for the repository, optionally filtered by a package path.
    */
-  public async getAllCommits(pathFilter?: string): Promise<GitCommit[]> {
+  public async getAllCommits(pathFilter?: string): Promise<Commit[]> {
     try {
 
       let pathArgument = '';
@@ -60,14 +60,14 @@ export class GitService {
       }
 
       // Parse the output
-      const commits: GitCommit[] = [];
+      const commits: Commit[] = [];
       const lines = stdout.trim().split('\n');
 
       for (const line of lines) {
         try {
           const [hash, author, date, message] = line.split('|');
 
-          const commit: GitCommit = {
+          const commit: Commit = {
             hash: hash.trim(),
             author: author.trim(),
             packageName: pathFilter || 'root',

package/src/services/{healthService.ts → health-service.ts}

@@ -9,16 +9,15 @@ import {
   funCheckSecurityAudit,
 } from '../utils/monorepo-scanner';
 
-import * as PrismaPkg from '@prisma/client';
-const PrismaClient = (PrismaPkg as any).PrismaClient || (PrismaPkg as any).default || PrismaPkg;
-const prisma = new PrismaClient();
+import { PackageHealthRepository, PackageRepository } from '../repositories';
+import type { TransformedPackageHealth, HealthResponse, PackageHealthModel } from '../types/database';
 
-export const getHealthSummaryService = async () => {
-  const packageHealthData = await prisma.packageHealth.findMany();
+export const getHealthSummaryService = async (): Promise<HealthResponse> => {
+  const packageHealthData = await PackageHealthRepository.findAll() as PackageHealthModel[];
   console.log('packageHealthData -->', packageHealthData.length);
 
   // Transform the data to match the expected frontend format
-  const packages = packageHealthData.map((pkg: any) => {
+  const packages = packageHealthData.map((pkg: PackageHealthModel) => {
     const health = {
       buildStatus: pkg.packageBuildStatus,
       testCoverage: pkg.packageTestCoverage,
@@ -36,11 +35,11 @@ export const getHealthSummaryService = async () => {
 
   // Calculate summary statistics
   const total = packages.length;
-  const healthy = packages.filter((pkg: any) => pkg.isHealthy).length;
-  const unhealthy = packages.filter((pkg: any) => !pkg.isHealthy).length;
+  const healthy = packages.filter((pkg: TransformedPackageHealth) => pkg.isHealthy).length;
+  const unhealthy = packages.filter((pkg: TransformedPackageHealth) => !pkg.isHealthy).length;
   const averageScore =
     packages.length > 0
-      ? packages.reduce((sum: any, pkg: any) => sum + pkg.health.overallScore, 0) /
+      ? packages.reduce((sum: number, pkg: TransformedPackageHealth) => sum + pkg.health.overallScore, 0) /
       packages.length
       : 0;
 
@@ -90,34 +89,17 @@ export const healthRefreshService = async (rootDir: string) => {
 
         console.log(pkg.name, '-->', health, packageStatus);
 
-        await prisma.packageHealth.upsert({
-          where: {
-            packageName: pkg.name,
-          },
-          update: {
-            packageOverallScore: overallScore.overallScore,
-            packageBuildStatus: buildStatus,
-            packageTestCoverage: testCoverage,
-            packageLintStatus: lintStatus,
-            packageSecurity: securityAudit,
-            packageDependencies: '',
-            updatedAt: new Date()
-          },
-          create: {
-            packageName: pkg.name,
-            packageOverallScore: overallScore.overallScore,
-            packageBuildStatus: buildStatus,
-            packageTestCoverage: testCoverage,
-            packageLintStatus: lintStatus,
-            packageSecurity: securityAudit,
-            packageDependencies: '',
-          },
+        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 prisma.package.update({
-          where: { name: pkg.name },
-          data: { status: packageStatus },
-        });
+        await PackageRepository.updateStatus(pkg.name, packageStatus);
         return {
           packageName: pkg.name,
           health,

package/src/services/package-service.ts

@@ -0,0 +1,201 @@
+import { scanMonorepo } from '../utils/utilities';
+import { generateReports } from '../utils/monorepo-scanner';
+import { ciStatusManager } from '../utils/ci-status';
+import { PackageRepository, CommitRepository, DependencyRepository } from '../repositories';
+import type { PackageInfo, DependencyInfo, PackageReport } from '../types';
+import { getCommitsByPathService } from './commit-service';
+import type { PackageModel } from '../types/database';
+
+interface TransformedPackage {
+  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;
+  createdAt?: Date;
+  lastUpdated?: Date;
+}
+
+interface PackageDetail extends TransformedPackage {
+  report?: PackageReport;
+  ciStatus?: Record<string, unknown>;
+}
+
+/**
+ * Get package dependencies
+ */
+function getPackageDependenciesInfo(pkg: PackageInfo): DependencyInfo[] {
+  const allDeps: DependencyInfo[] = [];
+  Object.keys(pkg.dependencies || {}).forEach(depName => {
+    allDeps.push({
+      name: depName,
+      version: pkg.dependencies[depName],
+      type: 'dependency',
+      latest: '',
+      outdated: false,
+    });
+  });
+  Object.keys(pkg.devDependencies || {}).forEach(depName => {
+    allDeps.push({
+      name: depName,
+      version: pkg.devDependencies[depName],
+      type: 'devDependency',
+      latest: '',
+      outdated: false,
+    });
+  });
+  Object.keys(pkg.peerDependencies || {}).forEach(depName => {
+    allDeps.push({
+      name: depName,
+      version: pkg.peerDependencies[depName]!,
+      type: 'peerDependency',
+      latest: '',
+      outdated: false,
+    });
+  });
+  return allDeps;
+}
+
+/**
+ * Store packages in database using repository pattern
+ */
+async function storePackage(pkg: PackageInfo): Promise<void> {
+  try {
+    // Create or update package using repository
+    await PackageRepository.upsert({
+      name: pkg.name,
+      version: pkg.version,
+      type: pkg.type,
+      path: pkg.path,
+      description: pkg.description,
+      license: pkg.license,
+      repository: pkg.repository,
+      scripts: pkg.scripts,
+      dependencies: pkg.dependencies,
+      devDependencies: pkg.devDependencies,
+      peerDependencies: pkg.peerDependencies,
+      maintainers: pkg.maintainers.join(','),
+      status: '',
+    });
+
+    // Store commits using repository
+    const commits = await getCommitsByPathService(pkg.path ?? '');
+    if (commits.length) {
+      await CommitRepository.storeMany(pkg.name, commits);
+    }
+
+    // Store dependencies using repository
+    const dependenciesInfo = getPackageDependenciesInfo(pkg);
+    if (dependenciesInfo.length) {
+      await DependencyRepository.storeMany(pkg.name, dependenciesInfo);
+    }
+  } catch (error) {
+    console.warn(` Failed to store report for ${pkg.name}:`, error);
+  }
+}
+
+export const getPackagesService = async (rootPath: string) => {
+  let dbPackages = await PackageRepository.findAll();
+  if (!dbPackages.length) {
+    try {
+      const rootDir = rootPath;
+      console.log('rootDir -->', rootDir);
+      const packages = scanMonorepo(rootDir);
+      console.log('packages --> scan', packages.length);
+      for (const pkg of packages) {
+        await storePackage(pkg);
+      }
+    } catch (error) {
+      throw new Error('Error ' + error);
+    }
+    dbPackages = await PackageRepository.findAll();
+  }
+  const transformedPackages = dbPackages.map((pkg: PackageModel) => {
+    // We create a new object 'transformedPkg' based on the database record 'pkg'
+    const transformedPkg = { ...pkg };
+
+    // 1. Maintainers
+    transformedPkg.maintainers = pkg.maintainers
+      ? JSON.parse(pkg.maintainers)
+      : [];
+
+    // 2. Scripts/repository (should default to an object, not an array)
+    transformedPkg.scripts = pkg.scripts ? JSON.parse(pkg.scripts) : {};
+    transformedPkg.repository = pkg.repository
+      ? JSON.parse(pkg.repository)
+      : {};
+
+    // 3. Dependencies List
+    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 the fully transformed object
+  });
+
+  return transformedPackages;
+}
+
+export const refreshPackagesService = async (rootPath: string) => {
+  await PackageRepository.deleteAll();
+
+  const rootDir = rootPath;
+  const packages = scanMonorepo(rootDir);
+
+  console.log('packages -->', packages.length);
+  for (const pkg of packages) {
+    await storePackage(pkg);
+  }
+
+  return packages;
+}
+
+export const getPackageDetailService = async (name: string) => {
+
+  const pkg = await PackageRepository.findByNameWithRelations(name);
+  if (!pkg) {
+    return null;
+  }
+  const transformedPkg = { ...pkg };
+
+  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)
+    : [];
+
+  // Get additional package information
+  const reports = (await generateReports()) as unknown as PackageReport[] | undefined;
+  const packageReport = reports?.find((r: PackageReport) => r.package?.name === name);
+
+  const result: PackageDetail = {
+    ...transformedPkg,
+    report: packageReport,
+    ciStatus: await ciStatusManager.getPackageStatus(name),
+  };
+
+  return result;
+
+}

package/src/types/database.ts

@@ -6,6 +6,62 @@ export interface Commit {
   hash: string;
   message?: string;
   author?: string;
-  date?: string;
+  date: Date;
   type?: string;
+  packageName: string;
 }
+
+export interface PackageHealthModel {
+  packageName: string;
+  packageOverallScore: number;
+  packageBuildStatus: string;
+  packageTestCoverage: number;
+  packageLintStatus: string;
+  packageSecurity: string;
+  packageDependencies?: string;
+  updatedAt?: Date;
+}
+
+export interface TransformedPackageHealth {
+  packageName: string;
+  health: {
+    buildStatus: string;
+    testCoverage: number;
+    lintStatus: string;
+    securityAudit: string;
+    overallScore: number;
+  };
+  isHealthy: boolean;
+}
+
+export interface HealthSummary {
+  total: number;
+  healthy: number;
+  unhealthy: number;
+  averageScore: number;
+}
+
+export interface HealthResponse {
+  packages: TransformedPackageHealth[];
+  summary: HealthSummary;
+}
+
+export interface PackageModel {
+  name: string;
+  version?: string;
+  type?: string;
+  path?: string;
+  description?: string;
+  license?: string;
+  repository?: string;
+  scripts?: string;
+  dependencies?: string;
+  devDependencies?: string;
+  peerDependencies?: string;
+  maintainers?: string;
+  status?: string;
+  createdAt?: Date;
+  lastUpdated?: Date;
+}
+
+export type ConfigUpdateData = Record<string, unknown>;

package/src/types/git.ts

@@ -5,14 +5,14 @@
 /**
  * Interface representing a single commit object with key metadata.
  */
-export interface GitCommit {
-  hash: string;
-  author: string;
-  packageName: string;
-  date: Date;
-  message: string;
-  type: string;
-}
+// export interface GitCommit {
+//   hash: string;
+//   author: string;
+//   packageName: string;
+//   date: Date;
+//   message: string;
+//   type: string;
+// }
 
 /**
  * List of standard Conventional Commit types for validation.

package/src/types/index.ts

@@ -3,7 +3,7 @@
  */
 
 export type { MonodogConfig } from './config';
-export type { GitCommit } from './git';
+// export type { GitCommit } from './git';
 export { VALID_COMMIT_TYPES } from './git';
 export type { PackageInfo, DependencyInfo, MonorepoStats } from './package';
 export type { PackageHealth } from './health';