@intranefr/superbackend 1.6.7 → 1.7.8

package/autochangelog/src/controllers/repository.js

@@ -0,0 +1,780 @@
+const Repository = require("../models/Repository");
+const Project = require("../models/Project");
+const User = require("../models/User");
+const GitHubService = require("../services/github");
+const { checkSubscription, checkUsageLimits } = require("../middleware/auth");
+const logger = require("../../utils/logger");
+
+// Create a new repository
+const createRepository = async (req, res) => {
+  try {
+    const {
+      projectId,
+      githubRepoId,
+      githubRepoName,
+      githubRepoUrl,
+      githubRepoOwner,
+      githubRepoFullName,
+      name,
+      description,
+      settings,
+    } = req.body;
+
+    // Validation
+    if (
+      !projectId ||
+      !githubRepoId ||
+      !githubRepoName ||
+      !githubRepoUrl ||
+      !githubRepoOwner ||
+      !githubRepoFullName
+    ) {
+      return res.status(400).json({
+        success: false,
+        message: "Project ID and GitHub repository information are required.",
+      });
+    }
+
+    // Check if project exists and user owns it
+    const project = await Project.findById(projectId);
+    if (!project) {
+      return res.status(404).json({
+        success: false,
+        message: "Project not found.",
+      });
+    }
+
+    if (project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this project.",
+      });
+    }
+
+    // Check if user can create more repositories
+    const user = await User.findById(req.user._id);
+    const currentRepositories = await Repository.countDocuments({
+      projectId,
+      status: "active",
+    });
+
+    if (currentRepositories >= user.subscription.repositoriesLimit) {
+      return res.status(403).json({
+        success: false,
+        message: `You have reached your repository limit of ${user.subscription.repositoriesLimit}. Upgrade your plan to connect more repositories.`,
+      });
+    }
+
+    // Check if repository already exists for this project
+    const existingRepo = await Repository.existsForProject(
+      projectId,
+      githubRepoId,
+    );
+    if (existingRepo) {
+      return res.status(400).json({
+        success: false,
+        message: "This repository is already connected to this project.",
+      });
+    }
+
+    // Validate GitHub repository access
+    const userWithGithub = await User.findById(req.user._id);
+    if (!userWithGithub.githubAccessToken) {
+      return res.status(400).json({
+        success: false,
+        message:
+          "GitHub access token not found. Please connect your GitHub account first.",
+      });
+    }
+
+    const validation = await GitHubService.validateRepositoryAccess(
+      userWithGithub.githubAccessToken,
+      githubRepoOwner,
+      githubRepoName,
+    );
+
+    if (!validation.valid) {
+      return res.status(400).json({
+        success: false,
+        message: `Failed to access repository: ${validation.error}`,
+      });
+    }
+
+    // Create repository
+    const repository = new Repository({
+      projectId,
+      githubRepoId,
+      githubRepoName,
+      githubRepoUrl,
+      githubRepoOwner,
+      githubRepoFullName,
+      name: name || githubRepoName,
+      description: description || "",
+      githubAccessToken: userWithGithub.githubAccessToken,
+      githubRefreshToken: userWithGithub.githubRefreshToken,
+      defaultBranch: settings?.defaultBranch || "main",
+      includeCommitsWithoutPR: settings?.includeCommitsWithoutPR !== false,
+      includeMergeCommits: settings?.includeMergeCommits || false,
+      includeDraftPRs: settings?.includeDraftPRs || false,
+      includeClosedPRs: settings?.includeClosedPRs !== false,
+      features: {
+        issues: settings?.features?.issues !== false,
+        pullRequests: settings?.features?.pullRequests !== false,
+        releases: settings?.features?.releases !== false,
+        discussions: settings?.features?.discussions || false,
+      },
+    });
+
+    await repository.save();
+
+    // Update project's repository count
+    await project.updateRepositoryCount();
+
+    // Update user's usage count
+    await User.findByIdAndUpdate(req.user._id, {
+      $inc: { "usage.repositoriesCount": 1 },
+    });
+
+    // Populate project info
+    await repository.populate("projectId", "name slug");
+
+    logger.info(
+      `Repository created: ${repository.name} for project ${project.name} by user ${req.user.email}`,
+    );
+
+    res.status(201).json({
+      success: true,
+      message: "Repository created successfully.",
+      data: {
+        repository: repository.toJSON(),
+      },
+    });
+  } catch (error) {
+    logger.error("Create repository error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Get all repositories for a project
+const getRepositories = async (req, res) => {
+  try {
+    const { projectId } = req.params;
+    const { limit = 20, skip = 0, status = "active" } = req.query;
+
+    // Check if project exists and user owns it
+    const project = await Project.findById(projectId);
+    if (!project) {
+      return res.status(404).json({
+        success: false,
+        message: "Project not found.",
+      });
+    }
+
+    if (project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this project.",
+      });
+    }
+
+    const repositories = await Repository.findByProject(projectId, {
+      status,
+      limit: parseInt(limit),
+      skip: parseInt(skip),
+    });
+
+    res.json({
+      success: true,
+      data: {
+        repositories: repositories.map((r) => r.toJSON()),
+        pagination: {
+          limit: parseInt(limit),
+          skip: parseInt(skip),
+          total: repositories.length,
+        },
+      },
+    });
+  } catch (error) {
+    logger.error("Get repositories error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Get a specific repository by ID
+const getRepository = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    const repository = await Repository.findById(id).populate(
+      "projectId",
+      "name slug",
+    );
+    if (!repository) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found.",
+      });
+    }
+
+    // Check ownership through project
+    const project = await Project.findById(repository.projectId);
+    if (!project || project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this repository.",
+      });
+    }
+
+    const stats = await repository.getStatistics();
+
+    res.json({
+      success: true,
+      data: {
+        repository: {
+          ...repository.toJSON(),
+          statistics: stats,
+        },
+      },
+    });
+  } catch (error) {
+    logger.error("Get repository error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Update a repository
+const updateRepository = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { name, description, settings, tags, isPrivate } = req.body;
+
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found.",
+      });
+    }
+
+    // Check ownership through project
+    const project = await Project.findById(repository.projectId);
+    if (!project || project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this repository.",
+      });
+    }
+
+    // Update fields
+    if (name) repository.name = name.trim();
+    if (description !== undefined) repository.description = description.trim();
+    if (tags !== undefined)
+      repository.tags = tags.map((tag) => tag.toLowerCase().trim());
+    if (isPrivate !== undefined) repository.isPrivate = isPrivate;
+
+    if (settings) {
+      if (settings.defaultBranch)
+        repository.defaultBranch = settings.defaultBranch;
+      if (settings.includeCommitsWithoutPR !== undefined)
+        repository.includeCommitsWithoutPR = settings.includeCommitsWithoutPR;
+      if (settings.includeMergeCommits !== undefined)
+        repository.includeMergeCommits = settings.includeMergeCommits;
+      if (settings.includeDraftPRs !== undefined)
+        repository.includeDraftPRs = settings.includeDraftPRs;
+      if (settings.includeClosedPRs !== undefined)
+        repository.includeClosedPRs = settings.includeClosedPRs;
+
+      if (settings.features) {
+        repository.features = { ...repository.features, ...settings.features };
+      }
+    }
+
+    await repository.save();
+
+    logger.info(
+      `Repository updated: ${repository.name} by user ${req.user.email}`,
+    );
+
+    res.json({
+      success: true,
+      message: "Repository updated successfully.",
+      data: {
+        repository: repository.toJSON(),
+      },
+    });
+  } catch (error) {
+    logger.error("Update repository error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Delete a repository (soft delete)
+const deleteRepository = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found.",
+      });
+    }
+
+    // Check ownership through project
+    const project = await Project.findById(repository.projectId);
+    if (!project || project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this repository.",
+      });
+    }
+
+    // Soft delete - set status to 'deleted'
+    repository.status = "deleted";
+    await repository.save();
+
+    // Update project's repository count
+    await project.updateRepositoryCount();
+
+    // Update user's usage count
+
+    await User.findByIdAndUpdate(req.user._id, {
+      $inc: { "usage.repositoriesCount": -1 },
+    });
+
+    logger.info(
+      `Repository deleted: ${repository.name} by user ${req.user.email}`,
+    );
+
+    res.json({
+      success: true,
+      message: "Repository deleted successfully.",
+    });
+  } catch (error) {
+    logger.error("Delete repository error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Sync repository data from GitHub
+const syncRepository = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found.",
+      });
+    }
+
+    // Check ownership through project
+    const project = await Project.findById(repository.projectId);
+    if (!project || project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this repository.",
+      });
+    }
+
+    // Update sync status to in_progress
+    await repository.updateSyncStatus("partial");
+
+    try {
+      // Get repository information from GitHub
+      const githubRepo = await GitHubService.getRepository(
+        repository.githubAccessToken,
+        repository.githubRepoOwner,
+        repository.githubRepoName,
+      );
+
+      // Update repository metadata
+      await repository.updateMetadata({
+        totalCommits: githubRepo.size, // Approximate
+        totalPRs: 0, // Would need to fetch PRs
+        totalIssues: githubRepo.open_issues_count,
+        lastCommitSha: null, // Would need to fetch latest commit
+        lastCommitDate: new Date(),
+      });
+
+      // Update sync status to success
+      await repository.updateSyncStatus("success");
+
+      logger.info(
+        `Repository synced: ${repository.name} by user ${req.user.email}`,
+      );
+
+      res.json({
+        success: true,
+        message: "Repository synced successfully.",
+        data: {
+          repository: repository.toJSON(),
+        },
+      });
+    } catch (syncError) {
+      // Update sync status to failed
+      await repository.updateSyncStatus("failed", syncError.message);
+
+      logger.error(`Repository sync failed: ${repository.name}`, syncError);
+
+      res.status(500).json({
+        success: false,
+        message: "Failed to sync repository data from GitHub.",
+        error: syncError.message,
+      });
+    }
+  } catch (error) {
+    logger.error("Sync repository error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Get available months for changelog generation
+const getAvailableMonths = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found.",
+      });
+    }
+
+    // Check ownership through project
+    const project = await Project.findById(repository.projectId);
+    if (!project || project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this repository.",
+      });
+    }
+
+    const availableMonths = await repository.getAvailableMonths();
+
+    res.json({
+      success: true,
+      data: {
+        availableMonths,
+      },
+    });
+  } catch (error) {
+    logger.error("Get available months error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Validate repository access
+const validateRepository = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found.",
+      });
+    }
+
+    // Check ownership through project
+    const project = await Project.findById(repository.projectId);
+    if (!project || project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this repository.",
+      });
+    }
+
+    const validation = await GitHubService.validateRepositoryAccess(
+      repository.githubAccessToken,
+      repository.githubRepoOwner,
+      repository.githubRepoName,
+    );
+
+    res.json({
+      success: true,
+      data: {
+        valid: validation.valid,
+        error: validation.error,
+      },
+    });
+  } catch (error) {
+    logger.error("Validate repository error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Get repository statistics
+const getRepositoryStatistics = async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    const repository = await Repository.findById(id);
+    if (!repository) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found.",
+      });
+    }
+
+    // Check ownership through project
+    const project = await Project.findById(repository.projectId);
+    if (!project || project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this repository.",
+      });
+    }
+
+    const stats = await repository.getStatistics();
+
+    res.json({
+      success: true,
+      data: {
+        statistics: stats,
+      },
+    });
+  } catch (error) {
+    logger.error("Get repository statistics error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Get user's GitHub repositories
+const getUserGithubRepositories = async (req, res) => {
+  try {
+    const { page = 1, per_page = 100, type = "owner" } = req.query;
+
+    const user = await User.findById(req.user._id);
+    if (!user || !user.githubAccessToken) {
+      return res.status(400).json({
+        success: false,
+        message:
+          "GitHub access token not found. Please connect your GitHub account first.",
+      });
+    }
+
+    // Instantiate GitHub Service with user's access token
+    const githubService = new GitHubService(user.githubAccessToken);
+    const reposResponse = await githubService.getUserRepos({
+      page: parseInt(page),
+      per_page: parseInt(per_page),
+      sort: "updated",
+      visibility: "all",
+    });
+
+    if (!reposResponse.success) {
+      return res.status(400).json({
+        success: false,
+        message:
+          reposResponse.error?.message ||
+          "Failed to fetch repositories from GitHub",
+      });
+    }
+
+    // Filter out repositories already connected to any of user's projects
+    const userProjects = await Project.find({ ownerId: req.user._id });
+    const connectedRepoIds = new Set();
+
+    for (const project of userProjects) {
+      const projectRepos = await Repository.find({
+        projectId: project._id,
+        status: { $ne: "deleted" },
+      });
+      projectRepos.forEach((repo) => connectedRepoIds.add(repo.githubRepoId));
+    }
+
+    const filteredRepos = reposResponse.data.filter(
+      (repo) => !connectedRepoIds.has(repo.id.toString()),
+    );
+
+    res.json({
+      success: true,
+      data: {
+        repositories: filteredRepos,
+        connectedCount: connectedRepoIds.size,
+      },
+    });
+  } catch (error) {
+    logger.error("Get user GitHub repositories error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+// Connect a GitHub repository to a project
+const connectGithubRepository = async (req, res) => {
+  try {
+    const { projectId, repoFullName } = req.body;
+
+    // Validation
+    if (!projectId || !repoFullName) {
+      return res.status(400).json({
+        success: false,
+        message:
+          "Project ID and repository full name (owner/repo) are required.",
+      });
+    }
+
+    // Check if project exists and user owns it
+    const project = await Project.findById(projectId);
+    if (!project) {
+      return res.status(404).json({
+        success: false,
+        message: "Project not found.",
+      });
+    }
+
+    if (project.ownerId.toString() !== req.user._id.toString()) {
+      return res.status(403).json({
+        success: false,
+        message: "Access denied. You do not own this project.",
+      });
+    }
+
+    // Get user's GitHub access token
+
+    const user = await User.findById(req.user._id);
+    if (!user || !user.githubAccessToken) {
+      return res.status(400).json({
+        success: false,
+        message:
+          "GitHub access token not found. Please connect your GitHub account first.",
+      });
+    }
+
+    // Fetch repository details from GitHub
+    const githubService = new GitHubService(user.githubAccessToken);
+    const repoResponse = await githubService.getRepo(repoFullName);
+
+    if (!repoResponse.success) {
+      return res.status(400).json({
+        success: false,
+        message:
+          repoResponse.error?.message ||
+          "Failed to fetch repository from GitHub",
+      });
+    }
+
+    const ghRepo = repoResponse.data;
+
+    // Check if repository already exists for this project
+    const existingRepo = await Repository.existsForProject(
+      projectId,
+      ghRepo.id.toString(),
+    );
+    if (existingRepo) {
+      return res.status(400).json({
+        success: false,
+        message: "This repository is already connected to this project.",
+      });
+    }
+
+    // Check repository limit
+    const currentRepositories = await Repository.countDocuments({
+      projectId,
+      status: "active",
+    });
+
+    // Free plan allows 5 repositories per project
+    const repoLimit = 5;
+    if (currentRepositories >= repoLimit) {
+      return res.status(403).json({
+        success: false,
+        message: `You have reached the repository limit of ${repoLimit} for this project. Upgrade your plan to connect more repositories.`,
+      });
+    }
+
+    // Create the repository
+    const repository = new Repository({
+      projectId,
+      githubRepoId: ghRepo.id.toString(),
+      githubRepoName: ghRepo.name,
+      githubRepoUrl: ghRepo.html_url,
+      githubRepoOwner: ghRepo.owner.login,
+      githubRepoFullName: ghRepo.full_name,
+      name: ghRepo.name,
+      description: ghRepo.description || "",
+      defaultBranch: ghRepo.default_branch || "main",
+      githubAccessToken: user.githubAccessToken,
+      isPrivate: ghRepo.private,
+      metadata: {
+        totalCommits: 0,
+        totalPRs: 0,
+        totalIssues: ghRepo.open_issues_count || 0,
+      },
+    });
+
+    await repository.save();
+
+    // Update project's repository count
+    await Project.findByIdAndUpdate(projectId, {
+      $inc: { "metadata.totalRepositories": 1 },
+    });
+
+    logger.info(
+      `Repository connected: ${repository.name} for project ${project.name} by user ${req.user.email}`,
+    );
+
+    res.status(201).json({
+      success: true,
+      message: "Repository connected successfully.",
+      data: {
+        repository: repository.toJSON(),
+      },
+    });
+  } catch (error) {
+    logger.error("Connect GitHub repository error:", error);
+    res.status(500).json({
+      success: false,
+      message: "Internal server error.",
+    });
+  }
+};
+
+module.exports = {
+  createRepository,
+  getRepositories,
+  getRepository,
+  updateRepository,
+  deleteRepository,
+  syncRepository,
+  getAvailableMonths,
+  validateRepository,
+  getRepositoryStatistics,
+  getUserGithubRepositories,
+  connectGithubRepository,
+};