add comment in code

Author: codinghack30

src/config/db.config.js

@@ -1,24 +1,29 @@
 const dotenv = require("dotenv");
 
+// Load environment variables from .env file
 dotenv.config();
 
+// Parse integer values for database pool configuration from environment variables
 const max = parseInt(process.env.DB_POOL_MAX);
 const min = parseInt(process.env.DB_POOL_MIN);
 const acquire = parseInt(process.env.DB_POOL_ACQUIRE);
 const idle = parseInt(process.env.DB_POOL_IDLE);
 
+// Database connection configuration object
 const config = {
-    HOST: process.env.DB_HOST,
-    USER: process.env.DB_USER,
-    PASSWORD: process.env.DB_PASSWORD,
-    DB: process.env.DB_DATABASE,
-    dialect: process.env.DB_DIALECT,
+    HOST: process.env.DB_HOST, // Database host address
+    USER: process.env.DB_USER, // Database user
+    PASSWORD: process.env.DB_PASSWORD, // Database user's password
+    DB: process.env.DB_DATABASE, // Name of the database
+    dialect: process.env.DB_DIALECT, // SQL dialect (e.g., 'mysql', 'postgres')
     pool: {
-        max: max,
-        min: min,
-        acquire: acquire,
-        idle: idle,
+        // Pool configuration for managing database connections
+        max: max, // Maximum number of connections in pool
+        min: min, // Minimum number of connections in pool
+        acquire: acquire, // Maximum time (ms) that pool will try to get connection before throwing error
+        idle: idle, // Maximum time (ms) that a connection can be idle before being released
     },
 };
 
+// Export the configuration object for use in other parts of the application
 module.exports = config;

src/middlewares/requiredAdmin.js

@@ -1,7 +1,8 @@
-const dbConfig = require("../config/db.config.js");
+const dbConfig = require("../config/db.config.js"); // Import database configuration
 
 const Sequelize = require("sequelize");
 
+// Initialize Sequelize instance with database credentials and pool settings
 const sequelize = new Sequelize(dbConfig.DB, dbConfig.USER, dbConfig.PASSWORD, {
     host: dbConfig.HOST,
     dialect: dbConfig.dialect,
@@ -20,6 +21,7 @@ const db = {};
 db.Sequelize = Sequelize;
 db.sequelize = sequelize;
 
+// Import and initialize all models
 db.useraccount = require("./useraccount.model.js")(sequelize, Sequelize);
 db.user = require("./user.model.js")(sequelize, Sequelize);
 db.serviceprovider = require("./serviceprovider.model.js")(
@@ -30,40 +32,49 @@ db.profile = require("./profile.model.js")(sequelize, Sequelize);
 db.review = require("./review.model.js")(sequelize, Sequelize);
 db.transaction = require("./transaction.model.js")(sequelize, Sequelize);
 
+// Define associations between models
+
+// One-to-One relationship: UserAccount -> User
 db.useraccount.hasOne(db.user, { foreignKey: "userAccountId" });
 db.user.belongsTo(db.useraccount, {
     foreignKey: "userAccountId",
     onDelete: "CASCADE",
 });
 
-db.user.hasMany(db.profile, { foreginKey: "userId" });
-db.profile.belongsTo(db.user, { foreginKey: "userId", onDelete: "CASCADE" });
+// One-to-Many relationship: User -> Profile
+db.user.hasMany(db.profile, { foreignKey: "userId" });
+db.profile.belongsTo(db.user, { foreignKey: "userId", onDelete: "CASCADE" });
 
-db.user.hasMany(db.review, { foreginKey: "userId" });
-db.review.belongsTo(db.user, { foreginKey: "userId", onDelete: "CASCADE" });
+// One-to-Many relationship: User -> Review
+db.user.hasMany(db.review, { foreignKey: "userId" });
+db.review.belongsTo(db.user, { foreignKey: "userId", onDelete: "CASCADE" });
 
-db.user.hasMany(db.transaction, { foreginKey: "userId" });
+// One-to-Many relationship: User -> Transaction
+db.user.hasMany(db.transaction, { foreignKey: "userId" });
 db.transaction.belongsTo(db.user, {
-    foreginKey: "userId",
+    foreignKey: "userId",
     onDelete: "CASCADE",
 });
 
-db.serviceprovider.hasMany(db.profile, { foreginKey: "serviceProviderId" });
+// One-to-Many relationship: ServiceProvider -> Profile
+db.serviceprovider.hasMany(db.profile, { foreignKey: "serviceProviderId" });
 db.profile.belongsTo(db.serviceprovider, {
     foreignKey: "serviceProviderId",
     onDelete: "CASCADE",
 });
 
-db.serviceprovider.hasMany(db.review, { foreginKey: "serviceProviderId" });
+// One-to-Many relationship: ServiceProvider -> Review
+db.serviceprovider.hasMany(db.review, { foreignKey: "serviceProviderId" });
 db.review.belongsTo(db.serviceprovider, {
     foreignKey: "serviceProviderId",
     onDelete: "CASCADE",
 });
 
-db.serviceprovider.hasMany(db.transaction, { foreginKey: "serviceProviderId" });
+// One-to-Many relationship: ServiceProvider -> Transaction
+db.serviceprovider.hasMany(db.transaction, { foreignKey: "serviceProviderId" });
 db.transaction.belongsTo(db.serviceprovider, {
     foreignKey: "serviceProviderId",
     onDelete: "CASCADE",
 });
 
-module.exports = db;
+module.exports = db; // Export the configured `db` object for use in other parts of the application

src/models/index.js

@@ -41,21 +41,24 @@ module.exports = (sequelize, Sequelize) => {
         },
     });
 
+    // Define a beforeCreate hook on the UserAccount model
     UserAccount.beforeCreate(async (userAccount, options) => {
+        // Check if password is provided and hash it using bcrypt
         if (userAccount.password) {
-            const salt = await bcrypt.genSalt(10);
+            const salt = await bcrypt.genSalt(10); // Generate salt with 10 rounds
             userAccount.password = await bcrypt.hash(
                 userAccount.password,
                 salt
-            );
+            ); // Hash the password with the generated salt
         }
 
+        // Check if securityAnswer is provided and hash it using bcrypt
         if (userAccount.securityAnswer) {
-            const salt = await bcrypt.genSalt(10);
+            const salt = await bcrypt.genSalt(10); // Generate salt with 10 rounds
             userAccount.securityAnswer = await bcrypt.hash(
                 userAccount.securityAnswer,
                 salt
-            );
+            ); // Hash the security answer with the generated salt
         }
     });
 

src/models/useraccount.model.js

@@ -8,30 +8,43 @@ const routes = require("./routes/api");
 
 const app = express();
 
+// Load environment variables from .env file
 dotenv.config();
 
+// Enable Cross-Origin Resource Sharing (CORS)
 app.use(cors());
+
+// Middleware to parse JSON request bodies
 app.use(express.json());
+// Middleware to parse URL-encoded request bodies
 app.use(express.urlencoded({ extended: true }));
+// HTTP request logger middleware for logging requests to the console
 app.use(morgan("dev"));
 
 const PORT = process.env.PORT;
 const HOST = process.env.HOST;
 
+// Sync the database models with the database.
+// If `force: true`, it will drop and recreate tables each time the server starts.
+// Commented out alternative sync which only syncs without dropping existing tables.
 // db.sequelize.sync().then(() => {
 //     console.log("⏳ Database connected");
 // });
 
+// Force sync all models, which drops existing tables and re-creates them
 db.sequelize.sync({ force: true }).then(() => {
     console.log("⏳ New Database connected");
 });
 
+// Basic route to verify that the server is running
 app.get("/", (req, res) => {
     res.status(200).json("⏳ Server is running!");
 });
 
+// Mount the API routes under "/api/v1" path
 app.use("/api/v1", routes);
 
+// Start the server and listen on specified host and port
 app.listen(PORT, HOST, () => {
     console.log(`⏳ Server is running on http://${HOST}:${PORT}`);
 });