@manojkmfsi/monodog 1.2.0 → 1.2.2

package/dist/routes/release-api.js

@@ -16,26 +16,6 @@ const npm_publish_service_1 = require("../services/npm-publish-service");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const router = (0, express_1.Router)();
-/**
- * GET /api/releases/packages
- * Get list of packages available in workspace
- */
-router.get('/packages', async (req, res) => {
-    try {
-        const packages = publish_controller_1.publishController.getAvailablePackages(process.cwd());
-        res.json({
-            success: true,
-            packages,
-            count: packages.length,
-        });
-    }
-    catch (error) {
-        res.status(500).json({
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-        });
-    }
-});
 /**
  * POST /api/releases/analyze
  * Analyze changes for packages without publishing

package/dist/services/change-tracker-service.js

@@ -8,10 +8,63 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.changeTrackerService = exports.ChangeTrackerService = void 0;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
+const client_1 = require("@prisma/client");
 // NOTE: ChangeTrack and CommitChange types will be imported from @prisma/client after DB integration
 // Currently using inline types below for service implementation
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const prisma = new client_1.PrismaClient();
 class ChangeTrackerService {
+    /**
+     * Save a ChangeTrack record and its related commits to the database
+     */
+    async saveChangeTrack(result) {
+        // Save ChangeTrack
+        const changeTrack = await prisma.changeTrack.create({
+            data: {
+                packageName: result.packageName,
+                packageVersion: result.currentVersion,
+                detectionMethod: 'git',
+                detectionTimestamp: new Date(),
+                filesChanged: JSON.stringify(result.filesChanged.map(f => f.path)),
+                linesAdded: result.filesChanged.reduce((sum, f) => sum + (f.linesAdded || 0), 0),
+                linesRemoved: result.filesChanged.reduce((sum, f) => sum + (f.linesRemoved || 0), 0),
+                changeType: result.changeType,
+                affectedDependents: JSON.stringify(result.affectedDependents),
+                isReleaseReady: result.isReleaseReady,
+                lastAnalyzedCommit: result.commits[0]?.hash || '',
+                previousVersion: result.currentVersion,
+                proposedVersion: result.proposedVersion,
+                // createdAt, updatedAt auto
+            },
+        });
+        // Save related commits
+        for (const commit of result.commits) {
+            await prisma.commitChange.create({
+                data: {
+                    changeTrackId: changeTrack.id,
+                    hash: commit.hash,
+                    message: commit.message,
+                    author: commit.author,
+                    authorEmail: commit.authorEmail,
+                    type: commit.type,
+                    scope: commit.scope,
+                    isBreaking: commit.isBreaking,
+                    bodyText: commit.body,
+                    committedAt: commit.committedAt,
+                },
+            });
+        }
+    }
+    /**
+     * Load the latest ChangeTrack for a package
+     */
+    async getLatestChangeTrack(packageName) {
+        return prisma.changeTrack.findFirst({
+            where: { packageName },
+            orderBy: { createdAt: 'desc' },
+            include: { commits: true },
+        });
+    }
     /**
      * Analyze changes for a package since last release
      */
@@ -25,7 +78,7 @@ class ChangeTrackerService {
             const changeType = this.determineChangeType(commits);
             // 4. Identify affected dependents
             const affectedDependents = await this.identifyAffectedDependents(packageName);
-            return {
+            const result = {
                 packageName,
                 currentVersion,
                 changeType,
@@ -35,6 +88,9 @@ class ChangeTrackerService {
                 proposedVersion: this.calculateNextVersion(currentVersion, changeType),
                 isReleaseReady: changeType !== 'none',
             };
+            // Save to DB
+            await this.saveChangeTrack(result);
+            return result;
         }
         catch (error) {
             console.error(`Failed to analyze changes for ${packageName}:`, error);

package/dist/services/npm-publish-service.js

@@ -161,12 +161,6 @@ class NpmPublishService {
             const integrity = this.calculateSRI(tarballData);
             const pkgJsonPath = (0, path_1.join)('package.json');
             const pkgJson = JSON.parse(await readFileAsync((0, path_1.join)(tarballPath, '..', pkgJsonPath), 'utf8'));
-            // const tarballBuffer = await fs.readFile(tarballPath, null, (err, data) => {
-            //   if (err) {
-            //     throw new Error(`Failed to read tarball for upload: ${err.message}`);
-            //   }
-            //   return data;
-            // });
             const doc = {
                 _id: packageName,
                 name: packageName,
@@ -194,21 +188,6 @@ class NpmPublishService {
                     },
                 },
             };
-            // Prepare document for npm registry
-            // const doc = {
-            //   _id: `${packageName}@${version}`,
-            //   name: packageName,
-            //   version,
-            //   description: pkgJson.description || '',
-            //   dist: {
-            //     tarball: `${registry}/${packageName}/-/${basename(tarballPath)}`,
-            //     shasum,
-            //     integrity,
-            //   },
-            //   // Add minimal required metadata
-            //   _rev: '',
-            //   dependencies: {},
-            // };
             const encodedName = packageName.replace('/', '%2f');
             // Publish via npm registry REST API
             const response = await fetch(`${registry}/${encodedName}`, {

package/dist/services/publish-controller.js

@@ -15,6 +15,7 @@ const release_readiness_service_1 = require("./release-readiness-service");
 const secure_token_service_1 = require("./secure-token-service");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const publish_pipeline_service_1 = require("./publish-pipeline-service");
 class PublishController {
     constructor() {
         this.pipelines = new Map();
@@ -61,6 +62,23 @@ class PublishController {
      */
     async publish(request) {
         const pipelineId = this.generatePipelineId();
+        // Create pipeline in DB
+        const pipelineRecord = await publish_pipeline_service_1.publishPipelineService.createPipeline({
+            id: pipelineId,
+            packageNames: JSON.stringify(request.packageNames),
+            method: request.method || 'auto',
+            status: 'pending',
+            triggeredBy: request.userId || 'system',
+            triggeredAt: new Date(),
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            releaseVersion: request.versionMap ? Object.values(request.versionMap).join(',') : undefined,
+            releaseNotes: undefined, // Could be set if changelog is generated
+            conclusion: undefined,
+            completedAt: undefined,
+            errorMessage: undefined,
+            errorDetails: undefined,
+        });
         const status = {
             pipelineId,
             status: 'pending',
@@ -72,20 +90,22 @@ class PublishController {
         try {
             status.startedAt = new Date().toISOString();
             status.status = 'validating';
-            // 1. Validate packages
+            await publish_pipeline_service_1.publishPipelineService.updatePipeline(pipelineId, { status: 'validating', updatedAt: new Date() });
+            // 1. Get readiness
             const prep = await this.preparePublish(request);
             if (!prep.valid && !request.dryRun) {
+                await publish_pipeline_service_1.publishPipelineService.updatePipeline(pipelineId, { status: 'failed', updatedAt: new Date() });
                 throw new Error(`Packages not ready for publishing. Fix blockers and try again.`);
             }
             status.status = 'ready';
             status.progress = 20;
+            await publish_pipeline_service_1.publishPipelineService.updatePipeline(pipelineId, { status: 'ready', updatedAt: new Date() });
             // 2. Get credentials
             const npmToken = await secure_token_service_1.secureTokenService.getToken('npm', 'env');
-            const githubToken = request.method !== 'node'
-                ? await secure_token_service_1.secureTokenService.getToken('github', 'env')
-                : undefined;
+            const githubToken = request.method !== 'node' ? await secure_token_service_1.secureTokenService.getToken('github', 'env') : undefined;
             // 3. Publish each package
             status.status = 'publishing';
+            await publish_pipeline_service_1.publishPipelineService.updatePipeline(pipelineId, { status: 'publishing', updatedAt: new Date() });
             const publisherCount = request.packageNames.length;
             for (let i = 0; i < request.packageNames.length; i++) {
                 const packageName = request.packageNames[i];
@@ -94,6 +114,23 @@ class PublishController {
                 const result = await this.publishPackage(packageName, packagePath, request.versionMap?.[packageName], npmToken, githubToken, request);
                 status.results[packageName] = result;
                 status.progress = 20 + ((i + 1) / publisherCount) * 80;
+                // Store result in DB
+                await publish_pipeline_service_1.publishPipelineService.addPublishResult(pipelineId, {
+                    packageName,
+                    currentVersion: result.version,
+                    newVersion: result.version,
+                    status: result.success ? 'completed' : 'failed',
+                    result: result.success ? 'published' : 'error',
+                    error: result.errors?.join('\n') || undefined,
+                    errorDetails: result.errors?.join('\n') || undefined,
+                    npmPackageId: result.packageId,
+                    publishedAt: result.success ? new Date() : undefined,
+                    // tarballUrl: result.tarballUrl || undefined, // Not present in result
+                    gitTagCreated: result.gitTag || undefined,
+                    // gitCommitSha: result.gitCommitSha || undefined, // Not present in result
+                    // gitPushCompleted: result.gitPushCompleted || false, // Not present in result
+                    githubReleaseUrl: result.gitHubReleaseUrl || undefined,
+                });
             }
             // 4. Generate changelog entries
             if (!request.dryRun) {
@@ -103,12 +140,28 @@ class PublishController {
             status.status = 'completed';
             status.progress = 100;
             status.completedAt = new Date().toISOString();
+            await publish_pipeline_service_1.publishPipelineService.updatePipeline(pipelineId, {
+                status: 'completed',
+                completedAt: new Date(),
+                updatedAt: new Date(),
+                conclusion: 'success',
+                errorMessage: undefined,
+                errorDetails: undefined,
+            });
             console.info(`\n✅ Publish pipeline completed: ${pipelineId}`);
         }
         catch (error) {
             status.status = 'failed';
             status.error = error instanceof Error ? error.message : String(error);
             status.completedAt = new Date().toISOString();
+            await publish_pipeline_service_1.publishPipelineService.updatePipeline(pipelineId, {
+                status: 'failed',
+                errorMessage: status.error,
+                errorDetails: status.error,
+                completedAt: new Date(),
+                updatedAt: new Date(),
+                conclusion: 'failure',
+            });
             console.error(`\n❌ Publish pipeline failed: ${status.error}`);
         }
         return status;
@@ -191,13 +244,6 @@ class PublishController {
     getAllPipelines() {
         return Array.from(this.pipelines.values());
     }
-    /**
-     * Get list of available packages
-     */
-    getAvailablePackages(workspacePath) {
-        // Would scan packages directory and return available packages
-        return [];
-    }
     /**
      * Get detailed pipeline information
      */

package/dist/services/publish-pipeline-service.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishPipelineService = exports.PublishPipelineService = void 0;
+const client_1 = require("@prisma/client");
+const prisma = new client_1.PrismaClient();
+class PublishPipelineService {
+    /**
+     * Create a new publish pipeline record
+     */
+    async createPipeline(data) {
+        return prisma.publishPipeline.create({ data: data });
+    }
+    /**
+     * Update a publish pipeline record
+     */
+    async updatePipeline(id, data) {
+        return prisma.publishPipeline.update({ where: { id }, data: data });
+    }
+    /**
+     * Get a publish pipeline by ID
+     */
+    async getPipeline(id) {
+        return prisma.publishPipeline.findUnique({ where: { id } });
+    }
+    /**
+     * List all pipelines (optionally filter by status)
+     */
+    async listPipelines(status) {
+        return prisma.publishPipeline.findMany({
+            where: status ? { status } : undefined,
+            orderBy: { createdAt: 'desc' },
+        });
+    }
+    /**
+     * Add a publish result to a pipeline
+     */
+    async addPublishResult(pipelineId, result) {
+        return prisma.publishResult.create({
+            data: {
+                ...result,
+                publishPipelineId: pipelineId,
+            },
+        });
+    }
+    /**
+     * Get all results for a pipeline
+     */
+    async getResultsForPipeline(pipelineId) {
+        return prisma.publishResult.findMany({
+            where: { publishPipelineId: pipelineId },
+            orderBy: { newVersion: 'desc' },
+        });
+    }
+    /**
+     * Log a token usage event
+     */
+    async logTokenUsage(data) {
+        return prisma.tokenUsageLog.create({ data: data });
+    }
+}
+exports.PublishPipelineService = PublishPipelineService;
+exports.publishPipelineService = new PublishPipelineService();