CHG: Adress refactor

Database/models/address.js

@@ -1,42 +1,33 @@
-var mongoose = require('mongoose');
-var Schema = mongoose.Schema;
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
 
-addressSchema = new Schema({
-    _id: mongoose.Schema.Types.ObjectId,
-    user_id: {
-        type: String
+const addressSchema = new Schema({
+    user: {
+        type: Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
     },
-    address: [
-        {
-            name: {
-                type: String
-            },
-            userId: {
-                type: String
-            },
-            mobileNumber: {
-                type: String
-            },
-            pinCode: {
-                type: String
-            },
-            address: {
-                type: String
-            },
-            area: {
-                type: String
-            },
-            landMark: {
-                type: String
-            },
-            alterMobileNumber: {
-                type: String
-            }
-
-        }
-    ]
-},
-    { timestamps: true }
-);
+    name: {
+        type: String,
+        required: true
+    },
+    mobileNumber: {
+        type: String,
+        required: true
+    },
+    pinCode: {
+        type: String,
+        required: true
+    },
+    address: {
+        type: String,
+        required: true
+    },
+    area: String,
+    landMark: String,
+    alterMobileNumber: String
+}, {
+    timestamps: true
+});
 
 module.exports = mongoose.model('Address', addressSchema);

Database/models/user.js

@@ -65,34 +65,10 @@ const userSchema = new Schema({
     profilePic: {
         type: String
     },
-    address: [
-        {
-            name: {
-                type: String
-            },
-            userId: {
-                type: String
-            },
-            mobileNumber: {
-                type: String
-            },
-            pinCode: {
-                type: String
-            },
-            address: {
-                type: String
-            },
-            area: {
-                type: String
-            },
-            landMark: {
-                type: String
-            },
-            alterMobileNumber: {
-                type: String
-            }
-        }
-    ]
+    addresses: [{
+        type: Schema.Types.ObjectId,
+        ref: 'Address'
+    }]
 }, {
     timestamps: true // This adds `createdAt` and `updatedAt` fields
 });

routes/address.js

@@ -3,97 +3,99 @@ const router = express.Router();
 const mongoose = require("mongoose");
 const Address = require("../Database/models/address");
 
-function successResponse(message) {
-    return {
-        "status": 200,
-        "connection": "Connected",
-        "message": message
-    }
-}
-
-function failedResponse(message) {
-    return {
-        "status": 400,
-        "connection": "Dissconnected",
-        "message": message
-    }
-}
-
-//Post order
-router.post("/", async (req, res, next) => {
-
-    console.log(req.body);
-
-    const address = new Address(req.body);
-
-    try {
-        const address = await address.save();
-
-        res.status(500).send(successResponse(address));
-    } catch (err) {
-        console.log(err);
-        res.status(500).send(failedResponse(err));
-    }
-
-});
-
-router.get("/:user_id", async (req, res, next) => {
-
-    console.log(req.params.user_id);
-
-    try {
-        const orders = await Address.find({ user_id: req.params.user_id });
-        res.status(200).send(successResponse(orders));
-    } catch (err) {
-        res.status(500).send(failedResponse(err));
-    }
-});
-
-//UPDATE
-router.put("/:id", async (req, res) => {
-    console.log(req.params.id);
-    console.log(req.body);
-
-    try {
-
-        Address.updateOne({ _id: req.params.id },
-            { $set: { status: req.body.status } }, function (err, data) {
-
-                if (err) {
-                    return res.status(500).send(failedResponse(err))
-                } else {
-                    return res.status(200).send(successResponse(data))
-                }
-            })
-
-    } catch (err) {
-        console.log(err);
-        res.status(500).send(failedResponse(err));
-    }
-
-
-});
-
-// //GET ALL
-router.get("/", async (req, res) => {
-    try {
-        const address = await Address.find();
-        res.status(200).json(successResponse(address));
-    } catch (err) {
-        res.status(500).json(failedResponse(err));
-    }
-});
-
-//DELETE
-router.delete("/:id", (req, res, next) => {
-    Order.remove({ _id: req.params.id })
-        .exec()
-        .then(result => {
-            res.status(200).send(successResponse(result));
-        })
-        .catch(err => {
-            res.status(500).send(failedResponse(err));
-        });
+// Response helpers
+const response = {
+  success: (data, message = "Success") => ({
+    status: "success",
+    code: 200,
+    data,
+    message
+  }),
+  error: (message = "Error", code = 400) => ({
+    status: "error",
+    code,
+    message
+  })
+};
+
+// Middleware for async error handling
+const asyncHandler = fn => (req, res, next) => 
+  Promise.resolve(fn(req, res, next)).catch(next);
+
+// Validation middleware
+const validateAddressData = (req, res, next) => {
+  const requiredFields = ['user', 'name', 'mobileNumber', 'pinCode', 'address'];
+  const missingFields = requiredFields.filter(field => !req.body[field]);
+  
+  if (missingFields.length > 0) {
+    return res.status(400).json(response.error(
+      `Missing required fields: ${missingFields.join(', ')}`
+    ));
+  }
+  next();
+};
+
+// Create address
+router.post("/", validateAddressData, asyncHandler(async (req, res) => {
+  const newAddress = new Address(req.body);
+  const savedAddress = await newAddress.save();
+  res.status(201).json(response.success(savedAddress, "Address created successfully"));
+}));
+
+// Get addresses by user
+router.get("/user/:userId", asyncHandler(async (req, res) => {
+  if (!mongoose.Types.ObjectId.isValid(req.params.userId)) {
+    return res.status(400).json(response.error("Invalid user ID"));
+  }
+
+  const addresses = await Address.find({ user: req.params.userId });
+  if (!addresses.length) {
+    return res.status(404).json(response.error("No addresses found", 404));
+  }
+  res.json(response.success(addresses));
+}));
+
+// Get all addresses
+router.get("/", asyncHandler(async (req, res) => {
+  const addresses = await Address.find().populate('user', 'username email');
+  res.json(response.success(addresses));
+}));
+
+// Update address
+router.put("/:id", validateAddressData, asyncHandler(async (req, res) => {
+  if (!mongoose.Types.ObjectId.isValid(req.params.id)) {
+    return res.status(400).json(response.error("Invalid address ID"));
+  }
+
+  const updatedAddress = await Address.findByIdAndUpdate(
+    req.params.id,
+    req.body,
+    { new: true, runValidators: true }
+  );
+
+  if (!updatedAddress) {
+    return res.status(404).json(response.error("Address not found", 404));
+  }
+  res.json(response.success(updatedAddress, "Address updated successfully"));
+}));
+
+// Delete address
+router.delete("/:id", asyncHandler(async (req, res) => {
+  if (!mongoose.Types.ObjectId.isValid(req.params.id)) {
+    return res.status(400).json(response.error("Invalid address ID"));
+  }
+
+  const deletedAddress = await Address.findByIdAndDelete(req.params.id);
+  if (!deletedAddress) {
+    return res.status(404).json(response.error("Address not found", 404));
+  }
+  res.json(response.success(null, "Address deleted successfully"));
+}));
+
+// Error handling middleware
+router.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json(response.error("Internal server error", 500));
 });
 
-module.exports = router;
+module.exports = router;