@intranefr/superbackend 1.6.7 → 1.7.8

package/autochangelog/src/services/changelog.js

@@ -0,0 +1,722 @@
+const simpleGit = require('simple-git');
+const { parse } = require('conventional-commits-parser');
+const logger = require('../../utils/logger');
+const Project = require('../models/Project');
+const Repository = require('../models/Repository');
+const Changelog = require('../models/Changelog');
+const GitHubService = require('./github');
+
+class ChangelogService {
+  constructor() {
+    this.git = simpleGit();
+  }
+
+  // Generate changelog for a specific month and year
+  async generateChangelog(projectId, repositoryId, month, year, options = {}) {
+    const { format = 'markdown', template = 'default', includeCommitsWithoutPR = true } = options;
+
+    try {
+      // Get project and repository
+      const [project, repository] = await Promise.all([
+        Project.findById(projectId),
+        Repository.findById(repositoryId),
+      ]);
+
+      if (!project || !repository) {
+        throw new Error('Project or repository not found');
+      }
+
+      // Check if changelog already exists
+      const existingChangelog = await Changelog.findOne({
+        projectId,
+        repositoryId,
+        month,
+        year,
+      });
+
+      if (existingChangelog) {
+        throw new Error('Changelog already exists for this period');
+      }
+
+      // Create changelog record with pending status
+      const changelog = new Changelog({
+        projectId,
+        repositoryId,
+        title: `${project.name} - ${this.getMonthName(month)} ${year}`,
+        description: `Changelog for ${this.getMonthName(month)} ${year}`,
+        month,
+        year,
+        format,
+        template,
+        status: 'generating',
+        generatedBy: repository.ownerId,
+      });
+
+      await changelog.save();
+
+      // Generate changelog content
+      const startTime = Date.now();
+      const content = await this.generateContent(repository, month, year, { format, template, includeCommitsWithoutPR });
+      const generationTime = Date.now() - startTime;
+
+      // Update changelog with content and completion status
+      changelog.content = content;
+      changelog.status = 'completed';
+      changelog.generationTime = generationTime;
+      changelog.generatedAt = new Date();
+
+      await changelog.save();
+
+      // Update repository metadata
+      await this.updateRepositoryMetadata(repository, month, year);
+
+      logger.info(`Changelog generated successfully: ${changelog.title}`);
+      return changelog;
+    } catch (error) {
+      logger.error('Changelog generation error:', error);
+      
+      // Update changelog status to failed if it was created
+      if (changelog) {
+        changelog.status = 'failed';
+        changelog.error = error.message;
+        await changelog.save();
+      }
+
+      throw error;
+    }
+  }
+
+  // Generate changelog content
+  async generateContent(repository, month, year, options = {}) {
+    const { format = 'markdown', template = 'default', includeCommitsWithoutPR = true } = options;
+
+    try {
+      // Get commit history for the specified month
+      const commits = await this.getCommitsForMonth(repository, month, year);
+      
+      // Parse commits and categorize them
+      const parsedCommits = await this.parseCommits(commits);
+      const categorizedCommits = this.categorizeCommits(parsedCommits);
+      
+      // Get additional context (PRs, issues, etc.)
+      const context = await this.getCommitContext(repository, commits, { includeCommitsWithoutPR });
+
+      // Generate content based on format and template
+      switch (format) {
+        case 'markdown':
+          return this.generateMarkdownContent(repository, month, year, categorizedCommits, context, template);
+        case 'html':
+          return this.generateHTMLContent(repository, month, year, categorizedCommits, context, template);
+        case 'json':
+          return this.generateJSONContent(repository, month, year, categorizedCommits, context);
+        default:
+          return this.generateMarkdownContent(repository, month, year, categorizedCommits, context, template);
+      }
+    } catch (error) {
+      logger.error('Content generation error:', error);
+      throw error;
+    }
+  }
+
+  // Get commits for a specific month
+  async getCommitsForMonth(repository, month, year) {
+    try {
+      const startDate = new Date(year, parseInt(month) - 1, 1);
+      const endDate = new Date(year, parseInt(month), 0, 23, 59, 59, 999);
+
+      // Use GitHub API to get commits
+      const commits = await GitHubService.getCommits(repository.githubAccessToken, 
+        repository.githubRepoOwner, 
+        repository.githubRepoName, {
+        since: startDate.toISOString(),
+        until: endDate.toISOString(),
+        sha: repository.defaultBranch,
+      });
+
+      return commits;
+    } catch (error) {
+      logger.error('Get commits error:', error);
+      throw new Error('Failed to fetch commits from GitHub');
+    }
+  }
+
+  // Parse commits using conventional commits parser
+  async parseCommits(commits) {
+    const parsedCommits = [];
+
+    for (const commit of commits) {
+      try {
+        const parsed = parse(commit.commit.message);
+        parsedCommits.push({
+          sha: commit.sha,
+          message: commit.commit.message,
+          author: {
+            name: commit.commit.author.name,
+            email: commit.commit.author.email,
+          },
+          date: commit.commit.author.date,
+          parsed,
+        });
+      } catch (error) {
+        // If parsing fails, include the commit as-is
+        parsedCommits.push({
+          sha: commit.sha,
+          message: commit.commit.message,
+          author: {
+            name: commit.commit.author.name,
+            email: commit.commit.author.email,
+          },
+          date: commit.commit.author.date,
+          parsed: null,
+        });
+      }
+    }
+
+    return parsedCommits;
+  }
+
+  // Categorize commits by type
+  categorizeCommits(parsedCommits) {
+    const categories = {
+      'feat': [],
+      'fix': [],
+      'docs': [],
+      'style': [],
+      'refactor': [],
+      'test': [],
+      'chore': [],
+      'perf': [],
+      'ci': [],
+      'deps': [],
+      'other': [],
+    };
+
+    const authors = new Map();
+
+    for (const commit of parsedCommits) {
+      const type = commit.parsed?.type || 'other';
+      const category = this.mapCommitType(type);
+      
+      categories[category].push({
+        sha: commit.sha,
+        message: commit.message,
+        author: commit.author,
+        date: commit.date,
+        parsed: commit.parsed,
+      });
+
+      // Track authors
+      const authorKey = `${commit.author.name} <${commit.author.email}>`;
+      if (!authors.has(authorKey)) {
+        authors.set(authorKey, {
+          name: commit.author.name,
+          email: commit.author.email,
+          commits: 0,
+        });
+      }
+      authors.get(authorKey).commits++;
+    }
+
+    // Convert authors map to array and sort by commit count
+    const sortedAuthors = Array.from(authors.values())
+      .sort((a, b) => b.commits - a.commits);
+
+    return {
+      categories,
+      authors: sortedAuthors,
+      totalCommits: parsedCommits.length,
+    };
+  }
+
+  // Map commit types to standard categories
+  mapCommitType(type) {
+    const typeMap = {
+      'feat': 'feat',
+      'feature': 'feat',
+      'enhancement': 'feat',
+      'fix': 'fix',
+      'bugfix': 'fix',
+      'bug': 'fix',
+      'docs': 'docs',
+      'documentation': 'docs',
+      'style': 'style',
+      'formatting': 'style',
+      'refactor': 'refactor',
+      'refactoring': 'refactor',
+      'test': 'test',
+      'testing': 'test',
+      'chore': 'chore',
+      'maintenance': 'chore',
+      'perf': 'perf',
+      'performance': 'perf',
+      'ci': 'ci',
+      'continuous-integration': 'ci',
+      'deps': 'deps',
+      'dependencies': 'deps',
+    };
+
+    return typeMap[type] || 'other';
+  }
+
+  // Get additional context for commits (PRs, issues, etc.)
+  async getCommitContext(repository, commits, options = {}) {
+    const { includeCommitsWithoutPR = true } = options;
+
+    try {
+      const context = {
+        pullRequests: [],
+        issues: [],
+        releases: [],
+      };
+
+      // Get pull requests for the repository
+      const prs = await GitHubService.getPullRequests(repository.githubAccessToken,
+        repository.githubRepoOwner,
+        repository.githubRepoName, {
+        state: 'closed',
+        sort: 'updated',
+        direction: 'desc',
+      });
+
+      // Filter PRs that were merged in the specified time period
+      const commitShas = new Set(commits.map(c => c.sha));
+      
+      for (const pr of prs) {
+        if (pr.merged_at) {
+          const mergedDate = new Date(pr.merged_at);
+          const prDate = new Date(pr.created_at);
+          
+          // Check if PR was merged or created in our target period
+          if (this.isInSameMonth(mergedDate) || this.isInSameMonth(prDate)) {
+            context.pullRequests.push({
+              number: pr.number,
+              title: pr.title,
+              body: pr.body,
+              author: pr.user.login,
+              mergedAt: pr.merged_at,
+              createdAt: pr.created_at,
+              url: pr.html_url,
+              commits: pr.commits,
+              additions: pr.additions,
+              deletions: pr.deletions,
+            });
+          }
+        }
+      }
+
+      // Get issues
+      const issues = await GitHubService.getIssues(repository.githubAccessToken,
+        repository.githubRepoOwner,
+        repository.githubRepoName, {
+        state: 'closed',
+        sort: 'updated',
+        direction: 'desc',
+      });
+
+      for (const issue of issues) {
+        if (issue.pull_request) continue; // Skip PRs
+        
+        const issueDate = new Date(issue.closed_at || issue.created_at);
+        if (this.isInSameMonth(issueDate)) {
+          context.issues.push({
+            number: issue.number,
+            title: issue.title,
+            body: issue.body,
+            author: issue.user.login,
+            closedAt: issue.closed_at,
+            createdAt: issue.created_at,
+            url: issue.html_url,
+            labels: issue.labels.map(l => l.name),
+          });
+        }
+      }
+
+      // Get releases
+      const releases = await GitHubService.getReleases(repository.githubAccessToken,
+        repository.githubRepoOwner,
+        repository.githubRepoName);
+
+      for (const release of releases) {
+        const releaseDate = new Date(release.published_at);
+        if (this.isInSameMonth(releaseDate)) {
+          context.releases.push({
+            tagName: release.tag_name,
+            name: release.name,
+            body: release.body,
+            author: release.author.login,
+            publishedAt: release.published_at,
+            url: release.html_url,
+            assets: release.assets,
+          });
+        }
+      }
+
+      return context;
+    } catch (error) {
+      logger.error('Get commit context error:', error);
+      return {
+        pullRequests: [],
+        issues: [],
+        releases: [],
+      };
+    }
+  }
+
+  // Check if a date is in the same month as the target month/year
+  isInSameMonth(date, targetMonth, targetYear) {
+    return date.getMonth() + 1 === parseInt(targetMonth) && date.getFullYear() === parseInt(targetYear);
+  }
+
+  // Generate markdown content
+  generateMarkdownContent(repository, month, year, categorizedCommits, context, template) {
+    const monthName = this.getMonthName(month);
+    const dateRange = this.getDateRange(month, year);
+
+    let content = `# ${repository.name} - ${monthName} ${year}\n\n`;
+    content += `**Date Range:** ${dateRange}\n`;
+    content += `**Repository:** [${repository.githubRepoFullName}](${repository.githubRepoUrl})\n\n`;
+
+    // Summary
+    content += `## Summary\n\n`;
+    content += `- **Total Commits:** ${categorizedCommits.totalCommits}\n`;
+    content += `- **Contributors:** ${categorizedCommits.authors.length}\n`;
+    content += `- **Pull Requests:** ${context.pullRequests.length}\n`;
+    content += `- **Issues Closed:** ${context.issues.length}\n\n`;
+
+    // Releases
+    if (context.releases.length > 0) {
+      content += `## Releases\n\n`;
+      for (const release of context.releases) {
+        content += `- **[${release.tagName}](${release.url})** - ${release.name}\n`;
+        if (release.body) {
+          content += `  ${release.body.split('\n')[0]}\n`;
+        }
+        content += `\n`;
+      }
+    }
+
+    // Changes by Category
+    content += `## Changes by Category\n\n`;
+
+    const categoryOrder = [
+      'feat', 'fix', 'perf', 'refactor', 'test', 
+      'docs', 'style', 'ci', 'deps', 'chore', 'other'
+    ];
+
+    for (const category of categoryOrder) {
+      const commits = categorizedCommits.categories[category];
+      if (commits.length > 0) {
+        content += `### ${this.getCategoryDisplayName(category)}\n\n`;
+        
+        for (const commit of commits) {
+          const message = this.formatCommitMessage(commit.message);
+          content += `- ${message} (${commit.author.name})\n`;
+        }
+        content += `\n`;
+      }
+    }
+
+    // Pull Requests
+    if (context.pullRequests.length > 0) {
+      content += `## Pull Requests\n\n`;
+      for (const pr of context.pullRequests) {
+        content += `- **[#${pr.number}](${pr.url})** ${pr.title} by ${pr.author}\n`;
+      }
+      content += `\n`;
+    }
+
+    // Issues
+    if (context.issues.length > 0) {
+      content += `## Issues Closed\n\n`;
+      for (const issue of context.issues) {
+        content += `- **[#${issue.number}](${issue.url})** ${issue.title} by ${issue.author}\n`;
+      }
+      content += `\n`;
+    }
+
+    // Contributors
+    if (categorizedCommits.authors.length > 0) {
+      content += `## Contributors\n\n`;
+      for (const author of categorizedCommits.authors) {
+        content += `- **${author.name}** (${author.email}) - ${author.commits} commits\n`;
+      }
+      content += `\n`;
+    }
+
+    content += `---\n`;
+    content += `Generated by [AutoChangelog](https://autochangelog.com) on ${new Date().toISOString()}\n`;
+
+    return content;
+  }
+
+  // Generate HTML content
+  generateHTMLContent(repository, month, year, categorizedCommits, context, template) {
+    const monthName = this.getMonthName(month);
+    const dateRange = this.getDateRange(month, year);
+
+    let content = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>${repository.name} - ${monthName} ${year}</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; line-height: 1.6; color: #333; max-width: 800px; margin: 0 auto; padding: 20px; }
+        h1, h2, h3 { color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px; }
+        h1 { font-size: 2.5em; }
+        h2 { font-size: 1.8em; margin-top: 30px; }
+        h3 { font-size: 1.4em; margin-top: 25px; }
+        .summary { background: #f8f9fa; padding: 15px; border-radius: 5px; margin: 20px 0; }
+        .category { margin: 20px 0; }
+        .category h3 { display: inline-block; background: #3498db; color: white; padding: 5px 10px; border-radius: 3px; }
+        ul { padding-left: 20px; }
+        li { margin: 5px 0; }
+        .commit { font-family: monospace; font-size: 0.9em; color: #666; }
+        .author { font-weight: bold; color: #2c3e50; }
+        a { color: #3498db; text-decoration: none; }
+        a:hover { text-decoration: underline; }
+        .footer { margin-top: 40px; padding-top: 20px; border-top: 1px solid #eee; font-size: 0.9em; color: #666; }
+    </style>
+</head>
+<body>
+    <h1>${repository.name} - ${monthName} ${year}</h1>
+    <p><strong>Date Range:</strong> ${dateRange}</p>
+    <p><strong>Repository:</strong> <a href="${repository.githubRepoUrl}" target="_blank">${repository.githubRepoFullName}</a></p>
+
+    <div class="summary">
+        <h2>Summary</h2>
+        <ul>
+            <li><strong>Total Commits:</strong> ${categorizedCommits.totalCommits}</li>
+            <li><strong>Contributors:</strong> ${categorizedCommits.authors.length}</li>
+            <li><strong>Pull Requests:</strong> ${context.pullRequests.length}</li>
+            <li><strong>Issues Closed:</strong> ${context.issues.length}</li>
+        </ul>
+    </div>`;
+
+    // Releases
+    if (context.releases.length > 0) {
+      content += `<div class="category">
+            <h2>Releases</h2>
+            <ul>`;
+      for (const release of context.releases) {
+        content += `<li><strong><a href="${release.url}" target="_blank">${release.tagName}</a></strong> - ${release.name}`;
+        if (release.body) {
+          content += `<br><span class="commit">${release.body.split('\n')[0]}</span>`;
+        }
+        content += `</li>`;
+      }
+      content += `</ul></div>`;
+    }
+
+    // Changes by Category
+    content += `<div class="category">
+        <h2>Changes by Category</h2>`;
+
+    const categoryOrder = [
+      'feat', 'fix', 'perf', 'refactor', 'test', 
+      'docs', 'style', 'ci', 'deps', 'chore', 'other'
+    ];
+
+    for (const category of categoryOrder) {
+      const commits = categorizedCommits.categories[category];
+      if (commits.length > 0) {
+        content += `<div class="category">
+                <h3>${this.getCategoryDisplayName(category)}</h3>
+                <ul>`;
+        for (const commit of commits) {
+          const message = this.formatCommitMessage(commit.message);
+          content += `<li><span class="commit">${message}</span> <span class="author">(${commit.author.name})</span></li>`;
+        }
+        content += `</ul></div>`;
+      }
+    }
+
+    content += `</div>`;
+
+    // Pull Requests
+    if (context.pullRequests.length > 0) {
+      content += `<div class="category">
+            <h2>Pull Requests</h2>
+            <ul>`;
+      for (const pr of context.pullRequests) {
+        content += `<li><strong><a href="${pr.url}" target="_blank">#${pr.number}</a></strong> ${pr.title} by ${pr.author}</li>`;
+      }
+      content += `</ul></div>`;
+    }
+
+    // Issues
+    if (context.issues.length > 0) {
+      content += `<div class="category">
+            <h2>Issues Closed</h2>
+            <ul>`;
+      for (const issue of context.issues) {
+        content += `<li><strong><a href="${issue.url}" target="_blank">#${issue.number}</a></strong> ${issue.title} by ${issue.author}</li>`;
+      }
+      content += `</ul></div>`;
+    }
+
+    // Contributors
+    if (categorizedCommits.authors.length > 0) {
+      content += `<div class="category">
+            <h2>Contributors</h2>
+            <ul>`;
+      for (const author of categorizedCommits.authors) {
+        content += `<li><span class="author">${author.name}</span> (${author.email}) - ${author.commits} commits</li>`;
+      }
+      content += `</ul></div>`;
+    }
+
+    content += `<div class="footer">
+        <p>Generated by <a href="https://autochangelog.com" target="_blank">AutoChangelog</a> on ${new Date().toISOString()}</p>
+    </div>
+</body>
+</html>`;
+
+    return content;
+  }
+
+  // Generate JSON content
+  generateJSONContent(repository, month, year, categorizedCommits, context) {
+    const data = {
+      repository: {
+        name: repository.name,
+        fullName: repository.githubRepoFullName,
+        url: repository.githubRepoUrl,
+      },
+      period: {
+        month: parseInt(month),
+        year: parseInt(year),
+        monthName: this.getMonthName(month),
+      },
+      summary: {
+        totalCommits: categorizedCommits.totalCommits,
+        contributors: categorizedCommits.authors.length,
+        pullRequests: context.pullRequests.length,
+        issuesClosed: context.issues.length,
+      },
+      categories: categorizedCommits.categories,
+      authors: categorizedCommits.authors,
+      pullRequests: context.pullRequests,
+      issues: context.issues,
+      releases: context.releases,
+      generatedAt: new Date().toISOString(),
+      generator: 'AutoChangelog',
+    };
+
+    return JSON.stringify(data, null, 2);
+  }
+
+  // Helper methods
+  getMonthName(month) {
+    const months = [
+      'January', 'February', 'March', 'April', 'May', 'June',
+      'July', 'August', 'September', 'October', 'November', 'December'
+    ];
+    return months[parseInt(month) - 1] || 'Unknown';
+  }
+
+  getDateRange(month, year) {
+    const startDate = new Date(year, parseInt(month) - 1, 1);
+    const endDate = new Date(year, parseInt(month), 0);
+    return `${startDate.toLocaleDateString()} - ${endDate.toLocaleDateString()}`;
+  }
+
+  getCategoryDisplayName(category) {
+    const displayNames = {
+      'feat': 'Features',
+      'fix': 'Bug Fixes',
+      'perf': 'Performance',
+      'refactor': 'Refactoring',
+      'test': 'Tests',
+      'docs': 'Documentation',
+      'style': 'Code Style',
+      'ci': 'CI/CD',
+      'deps': 'Dependencies',
+      'chore': 'Maintenance',
+      'other': 'Other Changes',
+    };
+    return displayNames[category] || category;
+  }
+
+  formatCommitMessage(message) {
+    // Remove multiple newlines and trim
+    return message.split('\n')[0].trim();
+  }
+
+  // Update repository metadata after changelog generation
+  async updateRepositoryMetadata(repository, month, year) {
+    try {
+      // Update last changelog generated date
+      await Repository.findByIdAndUpdate(repository._id, {
+        $set: {
+          'metadata.lastChangelogGenerated': new Date(),
+        },
+      });
+    } catch (error) {
+      logger.error('Update repository metadata error:', error);
+    }
+  }
+
+  // Get available months for a repository
+  async getAvailableMonths(repositoryId) {
+    try {
+      const repository = await Repository.findById(repositoryId);
+      if (!repository) {
+        throw new Error('Repository not found');
+      }
+
+      // Get commit history
+      const commits = await this.getCommitHistory(repository);
+
+      // Get already generated changelogs
+      const generatedChangelogs = await Changelog.find({
+        repositoryId,
+        status: 'completed',
+      }).select('month year').lean();
+
+      const generatedMonths = new Set(
+        generatedChangelogs.map(c => `${c.year}-${c.month}`)
+      );
+
+      // Extract unique months from commits
+      const availableMonths = new Set();
+
+      commits.forEach(commit => {
+        const date = new Date(commit.commit.author.date);
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const key = `${year}-${month}`;
+        availableMonths.add(key);
+      });
+
+      // Return months that have commits but no generated changelog
+      const result = Array.from(availableMonths)
+        .filter(month => !generatedMonths.has(month))
+        .sort()
+        .reverse();
+
+      return result;
+    } catch (error) {
+      logger.error('Get available months error:', error);
+      throw error;
+    }
+  }
+
+  // Get commit history for a repository
+  async getCommitHistory(repository) {
+    try {
+      const commits = await GitHubService.getCommits(repository.githubAccessToken,
+        repository.githubRepoOwner,
+        repository.githubRepoName, {
+        sha: repository.defaultBranch,
+        per_page: 1000,
+      });
+
+      return commits;
+    } catch (error) {
+      logger.error('Get commit history error:', error);
+      throw new Error('Failed to fetch commit history');
+    }
+  }
+}
+
+module.exports = new ChangelogService();