feat(release-tracks): implement mongoose models for release track registry and snapshots

Author: seansica

app/models/release-tracks/model-factory.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const mongoose = require('mongoose');
+const logger = require('../../lib/logger');
+const { releaseTrackSnapshotSchema } = require('./release-track-snapshot-schema');
+
+/**
+ * ModelFactory manages dynamic Mongoose model creation and caching for release tracks.
+ *
+ * Each release track gets its own MongoDB collection (named by track_id, e.g. "release-track--<uuid>").
+ * This factory creates Mongoose models on demand and caches them so that repeated access
+ * to the same track reuses the same compiled model.
+ */
+class ModelFactory {
+  constructor() {
+    /** @type {Map<string, mongoose.Model>} */
+    this._cache = new Map();
+  }
+
+  /**
+   * Get or create a cached Mongoose model for a release track collection.
+   *
+   * @param {string} trackId - The release track ID (e.g. "release-track--<uuid>"),
+   *   which is also used as the MongoDB collection name.
+   * @returns {mongoose.Model} The Mongoose model bound to the track's collection.
+   */
+  getModel(trackId) {
+    if (this._cache.has(trackId)) {
+      return this._cache.get(trackId);
+    }
+
+    // Mongoose model names must be unique per connection. Use the trackId directly
+    // since it's already globally unique (release-track--<uuid>).
+    const model = mongoose.model(trackId, releaseTrackSnapshotSchema, trackId);
+    this._cache.set(trackId, model);
+
+    logger.verbose(`ModelFactory: Created model for collection "${trackId}"`);
+    return model;
+  }
+
+  /**
+   * Remove a cached model. Call this when a release track is deleted
+   * so the model doesn't linger in memory.
+   *
+   * @param {string} trackId - The release track ID to remove from cache.
+   */
+  removeModel(trackId) {
+    if (this._cache.has(trackId)) {
+      // Remove from Mongoose's internal model registry
+      delete mongoose.connection.models[trackId];
+      this._cache.delete(trackId);
+      logger.verbose(`ModelFactory: Removed model for collection "${trackId}"`);
+    }
+  }
+
+  /**
+   * Ensure indexes are created on a release track's collection.
+   * Call this after creating a new track to build the indexes defined in the schema.
+   *
+   * @param {string} trackId - The release track ID.
+   * @returns {Promise<void>}
+   */
+  async ensureIndexes(trackId) {
+    const model = this.getModel(trackId);
+    await model.ensureIndexes();
+    logger.verbose(`ModelFactory: Ensured indexes for collection "${trackId}"`);
+  }
+}
+
+// Singleton instance -- shared across the application
+const modelFactory = new ModelFactory();
+
+module.exports = modelFactory;

app/models/release-tracks/release-track-registry-model.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const mongoose = require('mongoose');
+
+// --- Validation patterns ---
+
+const TRACK_ID_RE = /^release-track--[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const TRACK_NAME_RE = /^[a-zA-Z0-9 ]+$/;
+const VERSION_RE = /^\d+\.\d+$/;
+const CRON_RE = /^(\S+\s+){4}\S+$/;
+
+// --- Sub-schemas ---
+
+const snapshotScheduleDefinition = {
+  mode: {
+    type: String,
+    enum: ['manual', 'cron', 'dates'],
+    default: 'manual',
+  },
+  cron: {
+    type: String,
+    validate: {
+      validator: (v) => CRON_RE.test(v),
+      message: (props) => `"${props.value}" is not a valid cron expression (expected 5 fields)`,
+    },
+  },
+  dates: { type: [Date], default: undefined },
+};
+const snapshotScheduleSchema = new mongoose.Schema(snapshotScheduleDefinition, { _id: false });
+
+// --- Registry document definition ---
+
+const releaseTrackRegistryDefinition = {
+  track_id: {
+    type: String,
+    required: [true, 'Release track ID is required'],
+    index: { unique: true },
+    validate: {
+      validator: (v) => TRACK_ID_RE.test(v),
+      message: (props) =>
+        `"${props.value}" is not a valid release track ID (expected "release-track--<uuid>")`,
+    },
+  },
+  type: {
+    type: String,
+    enum: ['standard', 'virtual'],
+    required: true,
+  },
+  name: {
+    type: String,
+    required: [true, 'Release track name is required'],
+    validate: {
+      validator: (v) => TRACK_NAME_RE.test(v),
+      message: (props) =>
+        `"${props.value}" is not a valid release track name (only alphanumeric characters and spaces allowed)`,
+    },
+  },
+  description: { type: String },
+
+  // Denormalized for fast listing (updated on each snapshot/tag)
+  latest_snapshot_modified: { type: Date },
+  latest_tagged_version: {
+    type: String,
+    default: null,
+    validate: {
+      validator: (v) => v === null || VERSION_RE.test(v),
+      message: (props) =>
+        `"${props.value}" is not a valid version (expected MAJOR.MINOR format, e.g. "1.0")`,
+    },
+  },
+  snapshot_count: { type: Number, default: 0 },
+  tagged_release_count: { type: Number, default: 0 },
+
+  // Virtual tracks only
+  snapshot_schedule: { type: snapshotScheduleSchema, default: undefined },
+
+  created_at: { type: Date, required: true },
+  updated_at: { type: Date, required: true },
+};
+
+// --- Schema creation ---
+
+const releaseTrackRegistrySchema = new mongoose.Schema(releaseTrackRegistryDefinition, {
+  collection: 'releaseTrackRegistry',
+  bufferCommands: false,
+});
+
+// --- Indexes ---
+
+releaseTrackRegistrySchema.index({ type: 1 });
+
+// --- Model creation ---
+
+const ReleaseTrackRegistryModel = mongoose.model(
+  'ReleaseTrackRegistry',
+  releaseTrackRegistrySchema,
+);
+
+module.exports = ReleaseTrackRegistryModel;