@intranefr/superbackend 1.6.7 → 1.7.8

package/autochangelog/src/models/Changelog.js

@@ -0,0 +1,443 @@
+const mongoose = require("mongoose");
+
+const changelogSchema = new mongoose.Schema(
+  {
+    projectId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Project",
+      required: true,
+    },
+    repositoryId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Repository",
+      required: true,
+    },
+
+    // Changelog Information
+    title: {
+      type: String,
+      required: true,
+      trim: true,
+      maxlength: [200, "Title cannot exceed 200 characters"],
+    },
+    description: {
+      type: String,
+      trim: true,
+      maxlength: [500, "Description cannot exceed 500 characters"],
+    },
+
+    // Time Period
+    month: {
+      type: String,
+      required: true,
+      enum: [
+        "01",
+        "02",
+        "03",
+        "04",
+        "05",
+        "06",
+        "07",
+        "08",
+        "09",
+        "10",
+        "11",
+        "12",
+      ],
+    },
+    year: {
+      type: Number,
+      required: true,
+      min: [2000, "Year must be 2000 or later"],
+      max: [2100, "Year must be 2100 or earlier"],
+      index: true,
+    },
+
+    // Content
+    content: {
+      type: String,
+      required: true,
+    },
+
+    // Format and Storage
+    format: {
+      type: String,
+      enum: ["markdown", "html", "json"],
+      default: "markdown",
+    },
+    downloadUrl: {
+      type: String,
+      trim: true,
+    },
+    fileSize: {
+      type: Number,
+      default: 0,
+    },
+
+    // Generation Status
+    status: {
+      type: String,
+      enum: ["pending", "generating", "completed", "failed"],
+      default: "pending",
+    },
+    error: {
+      type: String,
+      maxlength: [1000, "Error message cannot exceed 1000 characters"],
+    },
+
+    // Generation Metadata
+    generatedAt: {
+      type: Date,
+    },
+    generatedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "users", // SuperBackend User model
+    },
+    generationTime: {
+      type: Number, // in milliseconds
+    },
+
+    // Content Metadata
+    metadata: {
+      totalCommits: {
+        type: Number,
+        default: 0,
+      },
+      totalPRs: {
+        type: Number,
+        default: 0,
+      },
+      totalIssues: {
+        type: Number,
+        default: 0,
+      },
+      categories: [
+        {
+          type: String,
+          enum: [
+            "feat",
+            "feature",
+            "enhancement",
+            "fix",
+            "bugfix",
+            "bug",
+            "docs",
+            "documentation",
+            "style",
+            "formatting",
+            "refactor",
+            "refactoring",
+            "test",
+            "testing",
+            "chore",
+            "maintenance",
+            "perf",
+            "performance",
+            "ci",
+            "continuous-integration",
+            "deps",
+            "dependencies",
+          ],
+        },
+      ],
+      authors: [
+        {
+          name: String,
+          email: String,
+          commits: Number,
+        },
+      ],
+      dateRange: {
+        start: Date,
+        end: Date,
+      },
+    },
+
+    // GitHub Integration
+    github: {
+      releaseUrl: {
+        type: String,
+        trim: true,
+      },
+      releaseTag: {
+        type: String,
+        trim: true,
+      },
+      releaseNotes: {
+        type: String,
+      },
+      autoCreatedRelease: {
+        type: Boolean,
+        default: false,
+      },
+    },
+
+    // Sharing and Privacy
+    isPublic: {
+      type: Boolean,
+      default: false,
+    },
+    shareToken: {
+      type: String,
+      unique: true,
+      sparse: true,
+    },
+    viewCount: {
+      type: Number,
+      default: 0,
+    },
+    lastViewedAt: {
+      type: Date,
+    },
+
+    // Template and Customization
+    template: {
+      type: String,
+      enum: ["default", "angular", "conventional", "custom"],
+      default: "default",
+    },
+    customTemplate: {
+      type: String,
+    },
+
+    // Version Information
+    version: {
+      major: {
+        type: Number,
+        default: 0,
+      },
+      minor: {
+        type: Number,
+        default: 0,
+      },
+      patch: {
+        type: Number,
+        default: 0,
+      },
+      preRelease: {
+        type: String,
+      },
+      build: {
+        type: String,
+      },
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Compound indexes
+changelogSchema.index({ projectId: 1, month: 1, year: 1 }, { unique: true });
+changelogSchema.index({ repositoryId: 1, month: 1, year: 1 }, { unique: true });
+changelogSchema.index({ status: 1, generatedAt: 1 });
+changelogSchema.index({ generatedBy: 1, createdAt: -1 });
+
+// Pre-save middleware to generate share token
+changelogSchema.pre("save", function (next) {
+  if (this.isNew && this.isPublic && !this.shareToken) {
+    const crypto = require("crypto");
+    this.shareToken = crypto.randomBytes(16).toString("hex");
+  }
+  next();
+});
+
+// Static method to find changelogs by project
+changelogSchema.statics.findByProject = function (projectId, options = {}) {
+  const {
+    status = ["completed"],
+    limit = 20,
+    skip = 0,
+    sortBy = "createdAt",
+    sortOrder = -1,
+  } = options;
+
+  return this.find({
+    projectId,
+    status: { $in: Array.isArray(status) ? status : [status] },
+  })
+    .sort({ [sortBy]: sortOrder })
+    .limit(limit)
+    .skip(skip)
+    .populate("repositoryId", "name githubRepoName")
+    .populate("generatedBy", "name email");
+};
+
+// Static method to find changelogs by repository
+changelogSchema.statics.findByRepository = function (
+  repositoryId,
+  options = {},
+) {
+  const {
+    status = ["completed"],
+    limit = 20,
+    skip = 0,
+    sortBy = "createdAt",
+    sortOrder = -1,
+  } = options;
+
+  return this.find({
+    repositoryId,
+    status: { $in: Array.isArray(status) ? status : [status] },
+  })
+    .sort({ [sortBy]: sortOrder })
+    .limit(limit)
+    .skip(skip)
+    .populate("projectId", "name slug")
+    .populate("generatedBy", "name email");
+};
+
+// Static method to get available months for a repository
+changelogSchema.statics.getAvailableMonths = async function (repositoryId) {
+  const repository = await mongoose.model("Repository").findById(repositoryId);
+  if (!repository) {
+    throw new Error("Repository not found");
+  }
+
+  // Get commit history from repository
+  const commits = await repository.fetchCommitHistory();
+
+  // Get already generated changelogs
+  const generatedChangelogs = await this.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.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;
+};
+
+// Static method to check if changelog exists for a specific month/year
+changelogSchema.statics.existsForPeriod = function (repositoryId, month, year) {
+  return this.exists({
+    repositoryId,
+    month,
+    year,
+    status: { $ne: "deleted" },
+  });
+};
+
+// Instance method to update generation status
+changelogSchema.methods.updateStatus = async function (status, error = null) {
+  const updates = {
+    status,
+    generatedAt: status === "completed" ? new Date() : this.generatedAt,
+  };
+
+  if (error) {
+    updates.error = error;
+    updates.status = "failed";
+  } else {
+    updates.error = null;
+  }
+
+  return this.updateOne(updates);
+};
+
+// Instance method to update content and metadata
+changelogSchema.methods.updateContent = async function (
+  content,
+  metadata = {},
+) {
+  const updates = {
+    content,
+    "metadata.totalCommits":
+      metadata.totalCommits || this.metadata.totalCommits,
+    "metadata.totalPRs": metadata.totalPRs || this.metadata.totalPRs,
+    "metadata.totalIssues": metadata.totalIssues || this.metadata.totalIssues,
+    "metadata.categories": metadata.categories || this.metadata.categories,
+    "metadata.authors": metadata.authors || this.metadata.authors,
+    "metadata.dateRange": metadata.dateRange || this.metadata.dateRange,
+  };
+
+  return this.updateOne(updates);
+};
+
+// Instance method to increment view count
+changelogSchema.methods.incrementViewCount = async function () {
+  return this.updateOne({
+    $inc: { viewCount: 1 },
+    $set: { lastViewedAt: new Date() },
+  });
+};
+
+// Instance method to get changelog statistics
+changelogSchema.methods.getStatistics = async function () {
+  const repository = await mongoose
+    .model("Repository")
+    .findById(this.repositoryId);
+  const project = await mongoose.model("Project").findById(this.projectId);
+
+  return {
+    project: {
+      name: project?.name,
+      slug: project?.slug,
+    },
+    repository: {
+      name: repository?.name,
+      githubRepoName: repository?.githubRepoName,
+    },
+    changelog: {
+      title: this.title,
+      month: this.month,
+      year: this.year,
+      status: this.status,
+      format: this.format,
+      viewCount: this.viewCount,
+      generatedAt: this.generatedAt,
+      generationTime: this.generationTime,
+    },
+    content: {
+      totalCommits: this.metadata.totalCommits,
+      totalPRs: this.metadata.totalPRs,
+      totalIssues: this.metadata.totalIssues,
+      categories: this.metadata.categories,
+      authors: this.metadata.authors,
+      dateRange: this.metadata.dateRange,
+    },
+  };
+};
+
+// Instance method to generate version number
+changelogSchema.methods.generateVersion = function () {
+  const major = this.metadata.categories.includes("feat") ? 1 : 0;
+  const minor = this.metadata.categories.includes("fix") ? 1 : 0;
+  const patch = this.metadata.categories.includes("docs") ? 1 : 0;
+
+  return {
+    major: this.version.major + major,
+    minor: this.version.minor + minor,
+    patch: this.version.patch + patch,
+  };
+};
+
+// Clean up response
+changelogSchema.methods.toJSON = function () {
+  const obj = this.toObject();
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model("Changelog", changelogSchema);

package/autochangelog/src/models/Project.js

@@ -0,0 +1,226 @@
+const mongoose = require("mongoose");
+
+const projectSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: [true, "Project name is required"],
+      trim: true,
+      maxlength: [100, "Project name cannot exceed 100 characters"],
+    },
+    description: {
+      type: String,
+      trim: true,
+      maxlength: [500, "Description cannot exceed 500 characters"],
+    },
+    slug: {
+      type: String,
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+
+    // Ownership - uses SuperBackend's User and Organization models
+    ownerId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "users", // SuperBackend User model
+      required: true,
+    },
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organizations", // SuperBackend Organization model
+    },
+
+    // Status
+    status: {
+      type: String,
+      enum: ["active", "archived", "deleted"],
+      default: "active",
+    },
+
+    // Settings
+    settings: {
+      defaultBranch: {
+        type: String,
+        default: "main",
+      },
+      changelogTemplate: {
+        type: String,
+        enum: ["default", "angular", "conventional"],
+        default: "default",
+      },
+      includeCommitsWithoutPR: {
+        type: Boolean,
+        default: true,
+      },
+      includeMergeCommits: {
+        type: Boolean,
+        default: false,
+      },
+    },
+
+    // Metadata
+    metadata: {
+      createdAt: {
+        type: Date,
+        default: Date.now,
+      },
+      lastChangelogGenerated: {
+        type: Date,
+      },
+      totalRepositories: {
+        type: Number,
+        default: 0,
+      },
+      totalChangelogs: {
+        type: Number,
+        default: 0,
+      },
+    },
+
+    // Tags/Categories
+    tags: [
+      {
+        type: String,
+        trim: true,
+        lowercase: true,
+      },
+    ],
+
+    // Privacy
+    isPublic: {
+      type: Boolean,
+      default: false,
+    },
+
+    // GitHub Integration
+    githubIntegration: {
+      enabled: {
+        type: Boolean,
+        default: false,
+      },
+      webhookSecret: {
+        type: String,
+      },
+      autoGenerateOnPush: {
+        type: Boolean,
+        default: false,
+      },
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Indexes
+projectSchema.index({ ownerId: 1, status: 1 });
+projectSchema.index({ organizationId: 1, status: 1 });
+projectSchema.index({ tags: 1 });
+
+// Pre-save middleware to generate slug
+projectSchema.pre("save", async function (next) {
+  if (this.isModified("name")) {
+    let baseSlug = this.name
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+
+    // Check if slug already exists
+    const existingProject = await this.constructor.findOne({
+      slug: new RegExp(`^${baseSlug}(-\d+)?$`, "i"),
+    });
+    if (
+      existingProject &&
+      existingProject._id.toString() !== this._id.toString()
+    ) {
+      // Add timestamp or incrementing number to make unique
+      this.slug = `${baseSlug}-${Date.now().toString(36)}`;
+    } else {
+      this.slug = baseSlug;
+    }
+  }
+  next();
+});
+
+// Static method to find projects by user
+projectSchema.statics.findByUser = function (userId, options = {}) {
+  const { status = "active", limit = 10, skip = 0 } = options;
+
+  return this.find({
+    ownerId: userId,
+    status,
+  })
+    .sort({ updatedAt: -1 })
+    .limit(limit)
+    .skip(skip)
+    .populate("ownerId", "name email avatar");
+};
+
+// Static method to check if user can create more projects
+projectSchema.statics.canCreateProject = async function (userId) {
+  const user = await mongoose.model("users").findById(userId);
+  if (!user) return false;
+
+  const currentProjects = await this.countDocuments({
+    ownerId: userId,
+    status: "active",
+  });
+
+  return currentProjects < user.subscription.projectsLimit;
+};
+
+// Instance method to update repository count
+projectSchema.methods.updateRepositoryCount = async function () {
+  const Repository = mongoose.model("Repository");
+  const count = await Repository.countDocuments({
+    projectId: this._id,
+    status: "active",
+  });
+
+  return this.updateOne({ "metadata.totalRepositories": count });
+};
+
+// Instance method to update changelog count
+projectSchema.methods.updateChangelogCount = async function () {
+  const Changelog = mongoose.model("Changelog");
+  const count = await Changelog.countDocuments({
+    projectId: this._id,
+    status: { $in: ["completed", "failed"] },
+  });
+
+  return this.updateOne({ "metadata.totalChangelogs": count });
+};
+
+// Instance method to get project statistics
+projectSchema.methods.getStatistics = async function () {
+  const Repository = mongoose.model("Repository");
+  const Changelog = mongoose.model("Changelog");
+
+  const [repositories, changelogs] = await Promise.all([
+    Repository.find({ projectId: this._id, status: "active" })
+      .select("name githubRepoName lastSyncedAt")
+      .lean(),
+    Changelog.find({ projectId: this._id })
+      .sort({ createdAt: -1 })
+      .limit(5)
+      .select("month year status createdAt")
+      .lean(),
+  ]);
+
+  return {
+    repositories,
+    recentChangelogs: changelogs,
+    totalRepositories: repositories.length,
+    totalChangelogs: await Changelog.countDocuments({ projectId: this._id }),
+  };
+};
+
+// Clean up response
+projectSchema.methods.toJSON = function () {
+  const obj = this.toObject();
+  delete obj.__v;
+  return obj;
+};
+
+module.exports = mongoose.model("Project", projectSchema);