Implement Database models

Author: ailearningguy

database/booking.model.ts

@@ -0,0 +1,46 @@
+import { Schema, model, models, Document } from "mongoose";
+import Event from "./event.model";
+
+// Interface for the Booking document
+export interface IBooking extends Document {
+  eventId: Schema.Types.ObjectId;
+  email: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const bookingSchema = new Schema<IBooking>(
+  {
+    eventId: {
+      type: Schema.Types.ObjectId,
+      ref: "Event",
+      required: [true, "Event ID is required"],
+    },
+    email: {
+      type: String,
+      required: [true, "Email is required"],
+      match: [/.+\@.+\..+/, "Please enter a valid email address"],
+    },
+  },
+  {
+    timestamps: true, // Enable automatic createdAt and updatedAt fields
+  }
+);
+
+// Pre-save hook to verify that the referenced eventId exists
+bookingSchema.pre<IBooking>("save", async function (next) {
+  if (this.isNew) {
+    const eventExists = await Event.findById(this.eventId);
+    if (!eventExists) {
+      throw new Error("Event not found");
+    }
+  }
+  next();
+});
+
+// Add an index on eventId for faster queries
+bookingSchema.index({ eventId: 1 });
+
+const Booking = models.Booking || model<IBooking>("Booking", bookingSchema);
+
+export default Booking;

database/event.model.ts

@@ -0,0 +1,71 @@
+import { Schema, model, models, Document } from "mongoose";
+import slugify from "slugify";
+
+// Interface for the Event document
+export interface IEvent extends Document {
+  title: string;
+  slug: string;
+  description: string;
+  overview: string;
+  image: string;
+  venue: string;
+  location: string;
+  date: string;
+  time: string;
+  mode: "online" | "offline" | "hybrid";
+  audience: string;
+  agenda: string[];
+  organizer: string;
+  tags: string[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const eventSchema = new Schema<IEvent>(
+  {
+    title: { type: String, required: [true, "Title is required"] },
+    slug: { type: String, unique: true },
+    description: { type: String, required: [true, "Description is required"] },
+    overview: { type: String, required: [true, "Overview is required"] },
+    image: { type: String, required: [true, "Image is required"] },
+    venue: { type: String, required: [true, "Venue is required"] },
+    location: { type: String, required: [true, "Location is required"] },
+    date: { type: String, required: [true, "Date is required"] },
+    time: { type: String, required: [true, "Time is required"] },
+    mode: {
+      type: String,
+      enum: ["online", "offline", "hybrid"],
+      required: [true, "Mode is required"],
+    },
+    audience: { type: String, required: [true, "Audience is required"] },
+    agenda: { type: [String], required: [true, "Agenda is required"] },
+    organizer: { type: String, required: [true, "Organizer is required"] },
+    tags: { type: [String], required: [true, "Tags are required"] },
+  },
+  {
+    timestamps: true, // Enable automatic createdAt and updatedAt fields
+  }
+);
+
+// Pre-save hook for slug generation and data normalization
+eventSchema.pre<IEvent>("save", function (next) {
+  // Generate a URL-friendly slug from the title if it has been modified
+  if (this.isModified("title")) {
+    this.slug = slugify(this.title, { lower: true, strict: true });
+  }
+
+  // Validate and normalize the date to ISO format
+  if (this.date) {
+    const isoDate = new Date(this.date).toISOString();
+    this.date = isoDate;
+  }
+
+  next();
+});
+
+// Add a unique index to the slug field for faster queries
+eventSchema.index({ slug: 1 });
+
+const Event = models.Event || model<IEvent>("Event", eventSchema);
+
+export default Event;

database/index.ts

@@ -0,0 +1,4 @@
+import Event from "./event.model";
+import Booking from "./booking.model";
+
+export { Event, Booking };

lib/mongodb.ts

@@ -0,0 +1,55 @@
+import mongoose, { Mongoose } from "mongoose";
+
+const MONGODB_URI = process.env.MONGODB_URI;
+
+if (!MONGODB_URI) {
+  throw new Error(
+    "Please define the MONGODB_URI environment variable inside .env.local"
+  );
+}
+
+/**
+ * Global is used here to maintain a cached connection across hot reloads
+ * in development. This prevents connections from growing exponentially
+ * during API Route usage.
+ */
+interface MongooseCache {
+  conn: Mongoose | null;
+  promise: Promise<Mongoose> | null;
+}
+
+// Extend NodeJS.Global to include mongoose property
+declare global {
+  // eslint-disable-next-line no-var
+  var mongoose: MongooseCache | undefined;
+}
+
+let cached: MongooseCache = global.mongoose ?? { conn: null, promise: null };
+
+if (!cached) {
+  cached = (global as typeof globalThis).mongoose = {
+    conn: null,
+    promise: null,
+  };
+}
+
+async function connectDB() {
+  // If a connection is already cached, use it
+  if (cached.conn) {
+    return cached.conn;
+  }
+
+  // If a connection promise doesn't exist, create one
+  if (!cached.promise) {
+    const opts = {
+      bufferCommands: false,
+    };
+
+    cached.promise = mongoose.connect(MONGODB_URI!, opts);
+  }
+  // Wait for the connection promise to resolve and cache the connection
+  cached.conn = await cached.promise;
+  return cached.conn;
+}
+
+export default connectDB;