@intranefr/superbackend 1.6.7 → 1.7.8

package/autochangelog/src/models/Repository.js

@@ -0,0 +1,366 @@
+const mongoose = require("mongoose");
+
+const repositorySchema = new mongoose.Schema(
+  {
+    projectId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Project",
+      required: true,
+    },
+
+    // GitHub Information
+    githubRepoId: {
+      type: String,
+      required: true,
+    },
+    githubRepoName: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    githubRepoUrl: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    githubRepoOwner: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    githubRepoFullName: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+
+    // Repository Settings
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+      maxlength: [100, "Repository name cannot exceed 100 characters"],
+    },
+    description: {
+      type: String,
+      trim: true,
+      maxlength: [500, "Description cannot exceed 500 characters"],
+    },
+
+    // Authentication
+    githubAccessToken: {
+      type: String,
+      required: true,
+    },
+    githubRefreshToken: {
+      type: String,
+    },
+
+    // Configuration
+    defaultBranch: {
+      type: String,
+      default: "main",
+      trim: true,
+    },
+    includeCommitsWithoutPR: {
+      type: Boolean,
+      default: true,
+    },
+    includeMergeCommits: {
+      type: Boolean,
+      default: false,
+    },
+    includeDraftPRs: {
+      type: Boolean,
+      default: false,
+    },
+    includeClosedPRs: {
+      type: Boolean,
+      default: true,
+    },
+
+    // Status
+    status: {
+      type: String,
+      enum: ["active", "inactive", "error", "deleted"],
+      default: "active",
+    },
+
+    // Sync Information
+    lastSyncedAt: {
+      type: Date,
+    },
+    lastSyncStatus: {
+      type: String,
+      enum: ["success", "failed", "partial"],
+      default: "success",
+    },
+    lastSyncError: {
+      type: String,
+    },
+
+    // Metadata
+    metadata: {
+      totalCommits: {
+        type: Number,
+        default: 0,
+      },
+      totalPRs: {
+        type: Number,
+        default: 0,
+      },
+      totalIssues: {
+        type: Number,
+        default: 0,
+      },
+      lastCommitSha: {
+        type: String,
+      },
+      lastCommitDate: {
+        type: Date,
+      },
+      branches: [
+        {
+          name: String,
+          lastCommitSha: String,
+          lastCommitDate: Date,
+        },
+      ],
+    },
+
+    // Webhook
+    webhook: {
+      enabled: {
+        type: Boolean,
+        default: false,
+      },
+      webhookId: {
+        type: String,
+      },
+      webhookUrl: {
+        type: String,
+      },
+      secret: {
+        type: String,
+      },
+    },
+
+    // Tags
+    tags: [
+      {
+        type: String,
+        trim: true,
+        lowercase: true,
+      },
+    ],
+
+    // Privacy
+    isPrivate: {
+      type: Boolean,
+      default: false,
+    },
+
+    // GitHub Features
+    features: {
+      issues: {
+        type: Boolean,
+        default: true,
+      },
+      pullRequests: {
+        type: Boolean,
+        default: true,
+      },
+      releases: {
+        type: Boolean,
+        default: true,
+      },
+      discussions: {
+        type: Boolean,
+        default: false,
+      },
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Indexes
+repositorySchema.index({ projectId: 1, status: 1 });
+repositorySchema.index({ githubRepoId: 1 });
+repositorySchema.index({ githubRepoFullName: 1 });
+repositorySchema.index({ "metadata.lastCommitDate": 1 });
+
+// Pre-save middleware to validate GitHub URL
+repositorySchema.pre("save", function (next) {
+  if (this.isModified("githubRepoUrl")) {
+    try {
+      new URL(this.githubRepoUrl);
+    } catch (error) {
+      const err = new Error("Invalid GitHub repository URL");
+      return next(err);
+    }
+  }
+  next();
+});
+
+// Static method to find repositories by project
+repositorySchema.statics.findByProject = function (projectId, options = {}) {
+  const { status = "active", limit = 20, skip = 0 } = options;
+
+  return this.find({
+    projectId,
+    status,
+  })
+    .sort({ updatedAt: -1 })
+    .limit(limit)
+    .skip(skip)
+    .populate("projectId", "name slug");
+};
+
+// Static method to check if repository exists for project
+repositorySchema.statics.existsForProject = function (projectId, githubRepoId) {
+  return this.exists({
+    projectId,
+    githubRepoId,
+    status: { $ne: "deleted" },
+  });
+};
+
+// Static method to get repository by GitHub ID
+repositorySchema.statics.findByGithubId = function (githubRepoId) {
+  return this.findOne({
+    githubRepoId,
+    status: { $ne: "deleted" },
+  }).populate("projectId", "name slug ownerId");
+};
+
+// Instance method to update sync status
+repositorySchema.methods.updateSyncStatus = async function (
+  status,
+  error = null,
+) {
+  const updates = {
+    lastSyncedAt: new Date(),
+    lastSyncStatus: status,
+  };
+
+  if (error) {
+    updates.lastSyncError = error;
+  } else {
+    updates.lastSyncError = null;
+  }
+
+  return this.updateOne(updates);
+};
+
+// Instance method to update metadata
+repositorySchema.methods.updateMetadata = async function (metadata) {
+  return this.updateOne({
+    $set: {
+      "metadata.totalCommits":
+        metadata.totalCommits || this.metadata.totalCommits,
+      "metadata.totalPRs": metadata.totalPRs || this.metadata.totalPRs,
+      "metadata.totalIssues": metadata.totalIssues || this.metadata.totalIssues,
+      "metadata.lastCommitSha":
+        metadata.lastCommitSha || this.metadata.lastCommitSha,
+      "metadata.lastCommitDate":
+        metadata.lastCommitDate || this.metadata.lastCommitDate,
+    },
+  });
+};
+
+// Instance method to get available months for changelog generation
+repositorySchema.methods.getAvailableMonths = async function () {
+  const Changelog = mongoose.model("Changelog");
+
+  // Get all generated changelogs for this repository
+  const generatedChangelogs = await Changelog.find({
+    repositoryId: this._id,
+    status: "completed",
+  })
+    .select("month year")
+    .lean();
+
+  const generatedMonths = new Set(
+    generatedChangelogs.map((c) => `${c.year}-${c.month}`),
+  );
+
+  // Get commit history from metadata or fetch from GitHub
+  const commits = await this.fetchCommitHistory();
+
+  const availableMonths = new Set();
+
+  commits.forEach((commit) => {
+    const date = new Date(commit.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;
+};
+
+// Instance method to fetch commit history (placeholder for GitHub API integration)
+repositorySchema.methods.fetchCommitHistory = async function () {
+  // This would integrate with GitHub API or local git repository
+  // For now, return empty array
+  return [];
+};
+
+// Instance method to validate repository access
+repositorySchema.methods.validateAccess = async function () {
+  try {
+    // This would make a test API call to GitHub to validate access
+    // For now, return true
+    return { valid: true, error: null };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+};
+
+// Instance method to get repository statistics
+repositorySchema.methods.getStatistics = async function () {
+  const Changelog = mongoose.model("Changelog");
+
+  const [totalChangelogs, recentChangelogs] = await Promise.all([
+    Changelog.countDocuments({
+      repositoryId: this._id,
+      status: { $in: ["completed", "failed"] },
+    }),
+    Changelog.find({
+      repositoryId: this._id,
+    })
+      .sort({ createdAt: -1 })
+      .limit(5)
+      .select("month year status createdAt")
+      .lean(),
+  ]);
+
+  return {
+    totalChangelogs,
+    recentChangelogs,
+    lastSyncedAt: this.lastSyncedAt,
+    lastSyncStatus: this.lastSyncStatus,
+    metadata: this.metadata,
+  };
+};
+
+// Clean up response
+repositorySchema.methods.toJSON = function () {
+  const obj = this.toObject();
+  delete obj.githubAccessToken;
+  delete obj.githubRefreshToken;
+  delete obj.webhook.secret;
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model("Repository", repositorySchema);

package/autochangelog/src/models/User.js

@@ -0,0 +1,223 @@
+const mongoose = require("mongoose");
+const bcrypt = require("bcryptjs");
+
+const userSchema = new mongoose.Schema(
+  {
+    email: {
+      type: String,
+      required: [true, "Email is required"],
+      unique: true,
+      lowercase: true,
+      trim: true,
+      match: [
+        /^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,3})+$/,
+        "Please enter a valid email",
+      ],
+    },
+    password: {
+      type: String,
+      minlength: [6, "Password must be at least 6 characters long"],
+      // Password is optional for OAuth users (GitHub, etc.)
+      validate: {
+        validator: function (v) {
+          // If user has a githubId, password is optional
+          if (this.githubId) return true;
+          // Otherwise, password is required
+          return v && v.length >= 6;
+        },
+        message: "Password is required (min 6 characters)",
+      },
+    },
+    name: {
+      type: String,
+      trim: true,
+    },
+
+    // GitHub Integration
+    githubId: {
+      type: String,
+      sparse: true,
+    },
+    githubUsername: {
+      type: String,
+      sparse: true,
+    },
+    githubAccessToken: {
+      type: String,
+    },
+    githubRefreshToken: {
+      type: String,
+    },
+    githubEmail: {
+      type: String,
+      sparse: true,
+    },
+
+    // Profile
+    avatar: {
+      type: String,
+    },
+    isActive: {
+      type: Boolean,
+      default: true,
+    },
+    emailVerified: {
+      type: Boolean,
+      default: false,
+    },
+
+    // Subscription
+    subscription: {
+      plan: {
+        type: String,
+        enum: ["free", "pro", "enterprise"],
+        default: "free",
+      },
+      projectsLimit: {
+        type: Number,
+        default: 3,
+      },
+      repositoriesLimit: {
+        type: Number,
+        default: 5,
+      },
+      changelogsLimit: {
+        type: Number,
+        default: 10,
+      },
+      lastResetDate: {
+        type: Date,
+        default: Date.now,
+      },
+    },
+
+    // Usage tracking
+    usage: {
+      projectsCount: {
+        type: Number,
+        default: 0,
+      },
+      repositoriesCount: {
+        type: Number,
+        default: 0,
+      },
+      changelogsCount: {
+        type: Number,
+        default: 0,
+      },
+      lastActivity: {
+        type: Date,
+        default: Date.now,
+      },
+    },
+
+    // Security
+    lastLogin: {
+      type: Date,
+    },
+    loginAttempts: {
+      type: Number,
+      default: 0,
+    },
+    lockUntil: {
+      type: Date,
+    },
+
+    // Preferences
+    preferences: {
+      defaultChangelogFormat: {
+        type: String,
+        enum: ["markdown", "html", "json"],
+        default: "markdown",
+      },
+      notifications: {
+        email: {
+          type: Boolean,
+          default: true,
+        },
+        changelogGenerated: {
+          type: Boolean,
+          default: true,
+        },
+      },
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Indexes
+userSchema.index({ githubId: 1 });
+userSchema.index({ email: 1 });
+
+// Virtual for account lockout
+userSchema.virtual("isLocked").get(function () {
+  return !!(this.lockUntil && this.lockUntil > Date.now());
+});
+
+// Pre-save middleware to hash password
+userSchema.pre("save", async function (next) {
+  // Only hash the password if it has been modified (or is new) AND exists
+  if (!this.isModified("password") || !this.password) return next();
+
+  try {
+    // Hash the password with cost of 12
+    const salt = await bcrypt.genSalt(12);
+    this.password = await bcrypt.hash(this.password, salt);
+    next();
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Instance method to check password
+userSchema.methods.comparePassword = async function (candidatePassword) {
+  return bcrypt.compare(candidatePassword, this.password);
+};
+
+// Instance method to increment login attempts
+userSchema.methods.incLoginAttempts = function () {
+  // If we have a previous lock that has expired, restart at 1
+  if (this.lockUntil && this.lockUntil < Date.now()) {
+    return this.updateOne({
+      $unset: { lockUntil: 1 },
+      $set: { loginAttempts: 1 },
+    });
+  }
+
+  const updates = { $inc: { loginAttempts: 1 } };
+
+  // If we're at max attempts and not locked, lock the account
+  if (this.loginAttempts + 1 >= 5 && !this.isLocked) {
+    updates.$set = { lockUntil: Date.now() + 2 * 60 * 60 * 1000 }; // Lock for 2 hours
+  }
+
+  return this.updateOne(updates);
+};
+
+// Instance method to reset login attempts
+userSchema.methods.resetLoginAttempts = function () {
+  return this.updateOne({
+    $unset: { loginAttempts: 1, lockUntil: 1 },
+  });
+};
+
+// Instance method to update last activity
+userSchema.methods.updateLastActivity = function () {
+  return this.updateOne({ lastActivity: new Date() });
+};
+
+// Clean up response
+userSchema.methods.toJSON = function () {
+  const obj = this.toObject();
+  delete obj.password;
+  delete obj.githubAccessToken;
+  delete obj.githubRefreshToken;
+  delete obj.loginAttempts;
+  delete obj.lockUntil;
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model("users", userSchema);

package/autochangelog/src/routes/auth.routes.js

@@ -0,0 +1,32 @@
+const express = require('express');
+const { 
+  register, 
+  login, 
+  githubLogin, 
+  githubCallback, 
+  getProfile, 
+  updateProfile, 
+  changePassword, 
+  logout, 
+  refreshToken, 
+  deleteAccount 
+} = require('../controllers/auth');
+const { authenticate, authRateLimit } = require('../middleware/auth');
+
+const router = express.Router();
+
+// Public routes
+router.post('/register', authRateLimit, register);
+router.post('/login', authRateLimit, login);
+router.get('/github/login', githubLogin);
+router.get('/github/callback', githubCallback);
+router.post('/refresh', refreshToken);
+
+// Protected routes
+router.get('/profile', authenticate, getProfile);
+router.put('/profile', authenticate, updateProfile);
+router.post('/change-password', authenticate, changePassword);
+router.post('/logout', authenticate, logout);
+router.delete('/account', authenticate, deleteAccount);
+
+module.exports = router;

package/autochangelog/src/routes/changelog.routes.js

@@ -0,0 +1,42 @@
+const express = require('express');
+const { 
+  generateChangelog, 
+  getChangelogs, 
+  getRepositoryChangelogs, 
+  getChangelog, 
+  updateChangelog, 
+  deleteChangelog, 
+  getChangelogStatistics, 
+  getAvailableMonths, 
+  shareChangelog, 
+  unshareChangelog, 
+  getPublicChangelog, 
+  downloadChangelog 
+} = require('../controllers/changelog');
+const { authenticate, checkOwnership, checkSubscription, checkUsageLimits, apiRateLimit } = require('../middleware/auth');
+
+const router = express.Router();
+
+// Protected routes - require authentication
+router.use(authenticate);
+router.use(apiRateLimit);
+
+// Changelog CRUD operations
+router.post('/', checkUsageLimits, generateChangelog);
+router.get('/project/:projectId', getChangelogs);
+router.get('/repository/:repositoryId', getRepositoryChangelogs);
+router.get('/:id', getChangelog);
+router.put('/:id', checkOwnership('Changelog'), updateChangelog);
+router.delete('/:id', checkOwnership('Changelog'), deleteChangelog);
+
+// Changelog management
+router.get('/:id/statistics', checkOwnership('Changelog'), getChangelogStatistics);
+router.get('/:repositoryId/available-months', getAvailableMonths);
+router.post('/:id/share', checkOwnership('Changelog'), shareChangelog);
+router.post('/:id/unshare', checkOwnership('Changelog'), unshareChangelog);
+router.get('/download/:id', checkOwnership('Changelog'), downloadChangelog);
+
+// Public routes - for shared changelogs
+router.get('/share/:shareToken', getPublicChangelog);
+
+module.exports = router;