Organizing Code with Models and Controllers: structuring backend with models, services and controllers; data models for users/products using MongoDB (Mongoose); basic CRUD operations using Express and MongoDB

📖 Theory

Backend ને આકાર આપો

FestConnect હવે ખરો data સાચવે છે: users, events, registrations. Data અને logic વધે કે તરત જ એક જ file વાળો server ગૂંચવાડો બની જાય છે. સારી રીતે ગોઠવાયેલો backend બે જવાબદારીઓ અલગ પાડે છે: data કેવો દેખાય છે (models) અને દરેક route પર શું થાય છે (controllers).

Database માટે FestConnect MongoDB વાપરે છે (જે તમે સેમેસ્ટર 5 માં જોયું હતું), અને તે પણ Mongoose નામની library દ્વારા, જે data ના આકાર નક્કી કરે છે અને create, read, update તથા delete માટે સ્વચ્છ methods આપે છે. આ પાઠ models, controllers અને Mongoose સાથેનું CRUD આવરી લે છે, જેથી backend વધે તો પણ વ્યવસ્થિત રહે.

📖 Theory

Mongoose સાથે models

Mongoose એ Node માં MongoDB માટેની ODM (Object Data Modelling) library છે. તમે તમારા data નું વર્ણન Schema વડે કરો છો, એટલે કે fields અને એમના પ્રકારો, અને પછી એને Model માં ફેરવો છો. એ model જ તે collection સુધીનું તમારું દ્વાર છે: તમે એના વડે documents બનાવો છો અને એમના પર query કરો છો.

MongoDB documents (JSON જેવા પદાર્થો) ને collections માં સંઘરે છે (લવચીક rows વાળાં tables જેવાં). Mongoose નું schema MongoDB ની લવચીકતા પર રચના અને ચકાસણી ઉમેરે છે, જેથી દરેક Event પાસે યોગ્ય પ્રકારનું name અને date હોય જ. દરેક એકમ માટે (User, Event, Registration) સ્પષ્ટ model વ્યાખ્યાયિત કરવું એ વ્યવસ્થિત backend નો પાયો છે.

⌨️ Practical

Mongoose નું model

const mongoose = require('mongoose');

const eventSchema = new mongoose.Schema({
  name:  { type: String, required: true },
  date:  { type: Date,   required: true },
  seats: { type: Number, default: 50 },
});

// schema ને model માં ફેરવો ('events' collection):
const Event = mongoose.model('Event', eventSchema);
module.exports = Event;

This example runs in Gri-Learn on the web, where you can edit it and see the output.

📖 Theory

CRUD અને controllers

Model તમને સ્વચ્છ CRUD methods આપે છે, જે Promises પાછાં આપે છે (એટલે async અને await વાપરો):

• Create: Event.create({...}) (અથવા new Event({...}).save()).
• Read: Event.find() (બધાં) અથવા Event.findById(id) (એક).
• Update: Event.findByIdAndUpdate(id, {...}).
• Delete: Event.findByIdAndDelete(id).

Controller એ જગ્યા છે જ્યાં તમે route ના જવાબમાં આ methods બોલાવો છો. Controllers ને પોતાની files માં રાખવાથી (અને models ને એમની files માં) તમારી route ની વ્યાખ્યાઓ પાતળી રહે છે, એટલે કે route ફક્ત એટલું જ કહે કે 'POST /api/events એ createEvent પર જાય', અને ખરું logic controller પાસે રહે. સ્પષ્ટ વિભાજન, અને વધારવામાં સહેલું.

⌨️ Practical

Model વાપરતું controller (CRUD)

const Event = require('../models/event');

// બનાવવું
exports.createEvent = async (req, res) => {
  const event = await Event.create(req.body);
  res.status(201).json(event);
};

// બધાં વાંચવાં
exports.getEvents = async (req, res) => {
  const events = await Event.find();
  res.json(events);
};

// id પ્રમાણે કાઢી નાખવું
exports.deleteEvent = async (req, res) => {
  await Event.findByIdAndDelete(req.params.id);
  res.status(204).send();
};

This example runs in Gri-Learn on the web, where you can edit it and see the output.

🧩 Quiz

Mongoose પર ચાલતા backend માં Schema ની ભૂમિકા શી છે?

1. એ Express નો server ચાલુ કરે છે
2. એ MongoDB ના collection માટે data નો આકાર નક્કી કરે છે (fields અને એમના પ્રકારો), અને એને CRUD માટે વપરાતા Model માં ફેરવાય છે
3. એ CORS સંભાળે છે
4. એ route જેવું જ છે

💭 Think first

MongoDB schema વગરનું હોય તો Mongoose ના schemas શા માટે ઉમેરવા?

MongoDB તમને કોઈ પણ આકારનાં documents સંઘરવા દે છે. તો એની ઉપર Mongoose નું schema શા માટે લાદવું? વિચારીને પછી tap કરો.

✅ Summary

Key takeaways

• Models (data ના આકાર) ને controllers (route નું logic) થી અલગ પાડીને backend વ્યવસ્થિત કરો.
• Mongoose એ Node માં MongoDB માટેની ODM છે: Schema વ્યાખ્યાયિત કરો (fields અને પ્રકારો), અને એને Model માં ફેરવો.
• MongoDB JSON જેવાં documents ને collections માં સંઘરે છે; અને schema એના પર રચના તથા ચકાસણી ઉમેરે છે.
• Model સાથે CRUD: create (create કે save), read (find કે findById), update (findByIdAndUpdate), delete (findByIdAndDelete); આ બધાં Promises પાછાં આપે છે (async અને await વાપરો).
• Controllers routes ના જવાબમાં model ને બોલાવે છે; અને એમને અલગ files માં રાખવાથી routes પાતળાં રહે છે.
• Mongoose ના schemas MongoDB ની લવચીકતા પર ચકાસણી અને સુસંગતતા ઉમેરે છે.
• યાદ રાખવાની કડી: models data ને આકાર આપે, controllers logic સાચવે, અને Mongoose CRUD આપે.