@monodog/backend 1.2.6 → 1.2.7

package/dist/utils/helpers.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommits = getCommits;
+exports.storePackage = storePackage;
+exports.storeCommits = storeCommits;
+exports.getPackageDependenciesInfo = getPackageDependenciesInfo;
+exports.storeDependencies = storeDependencies;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+dotenv_1.default.config({ path: path_1.default.resolve(__dirname, '../.env') });
+const client_1 = require("@prisma/client");
+const config_loader_1 = require("../config-loader");
+const appConfig = (0, config_loader_1.loadConfig)();
+// Default settings
+const DEFAULT_PORT = 4000;
+const port = appConfig.server.port ?? DEFAULT_PORT; //Default port
+const host = appConfig.server.host ?? 'localhost'; //Default host
+const prisma = new client_1.PrismaClient();
+const API_BASE = `http://${host}:${port}/api`;
+async function getCommits(path) {
+    const res = await fetch(API_BASE + `/commits/` + encodeURIComponent(path));
+    if (!res.ok)
+        throw new Error('Failed to fetch commits');
+    return await res.json();
+}
+async function storeCommits(packageName, commits) {
+    console.log('💾 Storing commits for:' + packageName);
+    // Create or update dependencies
+    for (const commit of commits) {
+        try {
+            await prisma.commit.upsert({
+                where: {
+                    hash: commit.hash,
+                },
+                update: {
+                    message: commit.message,
+                    author: commit.author,
+                    date: commit.date,
+                    type: commit.type,
+                },
+                create: {
+                    hash: commit.hash,
+                    message: commit.message,
+                    author: commit.author,
+                    date: commit.date,
+                    type: commit.type,
+                    packageName: packageName,
+                },
+            });
+        }
+        catch (e) {
+            if (e instanceof client_1.Prisma.PrismaClientKnownRequestError &&
+                e.code === 'P2002') {
+                // Handle unique constraint violation (e.g., commit already exists)
+                console.warn(`Skipping commit: ${commit.hash} (Depenndency already exists)`);
+            }
+            else {
+                // Handle any other unexpected errors
+                console.error(`Failed to store commit: ${commit.hash}`, e);
+            }
+        }
+    }
+}
+/**
+ * Store packages in database
+ */
+async function storePackage(pkg) {
+    try {
+        // Create or update package
+        await prisma.package.upsert({
+            where: { name: pkg.name },
+            update: {
+                version: pkg.version,
+                type: pkg.type,
+                path: pkg.path,
+                description: pkg.description,
+                license: pkg.license,
+                repository: JSON.stringify(pkg.repository),
+                scripts: JSON.stringify(pkg.scripts),
+                lastUpdated: new Date(),
+            },
+            create: {
+                // Timestamps
+                createdAt: new Date(),
+                lastUpdated: new Date(),
+                // Key Metrics and Relationships
+                dependencies: JSON.stringify(pkg.dependencies), // The total number of direct dependencies (12 in your example)
+                // Manual Serialization Required: Stores a JSON array string of maintainers, e.g., '["team-frontend"]'
+                maintainers: pkg.maintainers.join(','),
+                // Manual Serialization Required: Stores a JSON array string of tags, e.g., '["core", "ui"]'
+                // Manual Serialization Required: Stores the scripts object as a JSON string
+                // Example: '{"dev": "vite", "build": "tsc && vite build"}'
+                scripts: JSON.stringify(pkg.scripts),
+                // Dependency Lists (Manual Serialization Required)
+                // Stores a JSON array string of dependencies.
+                // dependenciesList: JSON.stringify(pkg.dependenciesList),
+                devDependencies: JSON.stringify(pkg.devDependencies),
+                peerDependencies: JSON.stringify(pkg.peerDependencies),
+                name: pkg.name,
+                version: pkg.version,
+                type: pkg.type,
+                path: pkg.path,
+                description: pkg.description ?? '',
+                license: pkg.license ?? '',
+                repository: JSON.stringify(pkg.repository),
+                status: '',
+            },
+        });
+        const commits = await getCommits(pkg.path ?? '');
+        if (commits.length) {
+            await storeCommits(pkg.name, commits);
+        }
+        const dependenciesInfo = getPackageDependenciesInfo(pkg);
+        if (dependenciesInfo.length) {
+            await storeDependencies(pkg.name, dependenciesInfo);
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️  Failed to store report for ${pkg.name}:`, error);
+    }
+}
+/**
+ * Get package dependencies
+ */
+function getPackageDependenciesInfo(pkg) {
+    const allDeps = [];
+    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 dependencies in database
+ */
+async function storeDependencies(packageName, dependencies) {
+    console.log('💾 Storing Dependencies for:' + packageName);
+    // Create or update dependencies
+    for (const dep of dependencies) {
+        try {
+            await prisma.dependencyInfo.upsert({
+                where: {
+                    name_packageName: {
+                        // This refers to the composite unique constraint
+                        name: dep.name,
+                        packageName,
+                    },
+                },
+                update: {
+                    version: dep.version,
+                    type: dep.type,
+                    latest: dep.latest,
+                    outdated: dep.outdated,
+                },
+                create: {
+                    name: dep.name,
+                    version: dep.version,
+                    type: dep.type,
+                    latest: dep.latest,
+                    outdated: dep.outdated,
+                    packageName: packageName,
+                },
+            });
+            console.log('💾 Dependencies stored in database:' + dep.name);
+        }
+        catch (e) {
+            if (e instanceof client_1.Prisma.PrismaClientKnownRequestError &&
+                e.code === 'P2002') {
+                // Handle unique constraint violation (e.g., depedency already exists)
+                console.warn(`Skipping dependency: ${dep.name} (Depenndency already exists)`);
+            }
+            else {
+                // Handle any other unexpected errors
+                console.error(`Failed to store dependency: ${dep.name}`, e);
+            }
+        }
+    }
+}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@monodog/backend",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "description": "Backend API server for monodog monorepo dashboard",
+  "main": "dist/index.js",
   "license": "MIT",
-
+  "bin": {
+    "monodog-cli": "dist/cli.js"
+  },
   "scripts": {
     "dev": "tsx watch src/index.ts",
     "start": "tsx index.ts",
@@ -11,15 +14,13 @@
     "build": "rm -rf dist && tsc -p tsconfig.json",
     "prestart": "npm run build",
     "cli": "pnpm run build && node dist/cli.js",
-    "test": "jest --coverage",
     "clean": "rm -rf dist node_modules/.cache",
-    "test:coverage": "jest --coverage",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "db:url": "npx ts-node get-db-url.ts",
-    "migrate": "DATABASE_URL=$(npm run db:url --silent 2>/dev/null | tr -d '\\n')  npx prisma migrate dev",
-    "serve": "DATABASE_URL=$(npm run db:url --silent 2>/dev/null | tr -d '\\n')  ts-node dist/cli.js --serve "
-  },
+"db:url": "ts-node src/get-db-url.ts",
+   "generate": "DATABASE_URL=$(npm run db:url --silent 2>/dev/null | tr -d '\\n') prisma generate",
+    "migrate": "DATABASE_URL=$(npm run db:url --silent 2>/dev/null | tr -d '\\n') prisma migrate dev",
+"serve": "DATABASE_URL=$(npm run db:url --silent 2>/dev/null | tr -d '\\n') node dist/cli.js --serve"  },
   "dependencies": {
     "@monodog/ci-status": "1.1.1",
     "@monodog/monorepo-scanner": "1.0.7",

package/src/cli.ts

@@ -24,10 +24,12 @@ const args = process.argv.slice(2);
 
 // Default settings
 const DEFAULT_PORT = 4000;
-let serve = false;
 let rootPath = path.resolve(appConfig.workspace.root_dir ?? process.cwd()); // Default to the current working directory
 let port = appConfig.server.port ?? DEFAULT_PORT; //Default port
-let host = appConfig.server.host ?? 'localhost'; //Default port
+const host = appConfig.server.host ?? 'localhost'; //Default host
+
+let serve = false;
+
 
 // Simple argument parsing loop
 for (let i = 0; i < args.length; i++) {

package/src/utils/helpers.ts

@@ -8,8 +8,17 @@ import dotenv from 'dotenv';
 import path from 'path';
 dotenv.config({ path: path.resolve(__dirname, '../.env') });
 import { PrismaClient, Prisma, Commit } from '@prisma/client';
+import { loadConfig } from '../config-loader';
+
+  const appConfig = loadConfig();
+
+// Default settings
+const DEFAULT_PORT = 4000;
+const port = appConfig.server.port ?? DEFAULT_PORT; //Default port
+const host = appConfig.server.host ?? 'localhost'; //Default host
+
 const prisma = new PrismaClient();
-const API_BASE = `http://localhost:4000/api`;
+const API_BASE = `http://${host}:${port}/api`;
 
 async function getCommits(path: string): Promise<Commit[]> {
   const res = await fetch(API_BASE + `/commits/` + encodeURIComponent(path));