broll-express 1.0.0

package/.babelrc

@@ -0,0 +1,6 @@
+{
+    "presets": [
+      "@babel/preset-env"
+    ]
+  }
+  

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ananda krishnan g r
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "broll-express",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": " env-cmd -f .env.development node --no-warnings --watch --loader @babel/register ./start.js"
+  },
+  "author": "anandakrishnangr",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "babel-node": "^0.0.1-security",
+    "bcryptjs": "^2.4.3",
+    "body-parser": "^1.20.3",
+    "cors": "^2.8.5",
+    "env-cmd": "^10.1.0",
+    "express": "^4.21.1",
+    "joi": "^17.13.3",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.7.1",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.8",
+    "@babel/node": "^7.25.7",
+    "@babel/preset-env": "^7.25.8",
+    "@babel/register": "^7.25.7"
+  }
+}

package/src/app.js

@@ -0,0 +1,32 @@
+import express from 'express';
+import { connectMongoose } from './config/mongoConfig.js'
+import bodyParser from 'body-parser';
+import { createUser } from './controllers/signup.controller.js';
+import authRoute from './routes/auth.routes.js'
+import { validateRequest } from './middlewares/payloadValidation.middleware.js';
+import cors from 'cors'
+import { swaggerSpecs } from "./config/swaggerConfig.js";
+import swaggerUi from "swagger-ui-express"
+
+const app = express();
+connectMongoose()
+// Middleware to parse JSON requests
+app.use(cors());
+app.use(express.json());
+app.use(bodyParser.json({
+    limit: '5mb'
+}));
+app.use(bodyParser.urlencoded({ extended: false }))
+app.use(bodyParser.json())
+app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
+
+app.use(validateRequest)
+app.get('/', (req, res) => {
+    res.send('Welcome to the Demo App!');
+});
+
+app.post('/test', createUser)
+// app.post('/business',)
+app.use("/auth", authRoute)
+
+export default app // Export the app for use in server.js

package/src/config/mongoConfig.js

@@ -0,0 +1,9 @@
+import { default as mongoose } from "mongoose";
+
+export const connectMongoose =async () => {
+    return mongoose.connect("").then((res) => {
+        console.log("connected")
+    }).catch((err) => {
+        console.log("err")
+    })
+}

package/src/config/swaggerConfig.js

@@ -0,0 +1,27 @@
+import swaggerJsdoc from 'swagger-jsdoc'
+import { fileURLToPath } from 'url';
+import packageDetails from '../../package.json' assert {type: 'json'}
+import path from 'path';
+const PORT = process.env.PORT
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const options = {
+    definition: {
+        openapi: "3.0.0",
+        info: {
+            title: "Ecom API with Swagger",
+            version: packageDetails.version,
+            description: "A simple CRUD API application made with Express and documented with Swagger",
+        },
+        servers: [
+            {
+                url: `http://localhost:${PORT}`, // Replace with your server URL
+            },
+        ],
+    },
+    apis: [path.join(__dirname, "../routes/*.js")],
+};
+
+export const swaggerSpecs = swaggerJsdoc(options);
+
+

package/src/controllers/auth.controller.js

@@ -0,0 +1,22 @@
+import Login from "../models/auth.models.js"
+
+export const register = async (req, res, next) => {
+    try {
+        let { password, email } = req.body
+        await Login.create({ password, email })
+        res.send(200)
+    } catch (error) {
+        next(error)
+    }
+}
+
+export const login = async (req, res, next) => {
+    try {
+        let { password, email } = req.body
+        await Login.isUserAuthenticated(email, password)
+        res.send(200)
+    } catch (error) {
+        console.log(error)
+        next(error)
+    }
+}

package/src/controllers/signup.controller.js

@@ -0,0 +1,31 @@
+import mongoose from "mongoose"
+import user from "../models/user.models.js";
+
+
+export const createUser = async(req, res) => {
+    const session = await mongoose.startSession();
+
+    try {
+        session.startTransaction();
+
+        // Create a new address
+        const newUser = await user.create([{
+           firstName:"ananda",
+           lastName:"krishnan",
+           gender:"male"
+        }], { session });
+
+        // Commit the transaction
+        throw Error
+        await session.commitTransaction();
+        console.log('Transaction committed:', newUser);
+    } catch (error) {
+        // If an error occurs, abort the transaction
+        await session.abortTransaction();
+        console.error('Transaction aborted due to error:', error);
+    } finally {
+        session.endSession();
+    }
+
+
+}

package/src/library/auth.lib.js

@@ -0,0 +1,4 @@
+import bcryptjs from 'bcryptjs'
+
+export const hashPassword = async (password) => bcryptjs.hash(password, await bcryptjs.genSalt(10))
+export const comparePassword = async (password, hash) => bcryptjs.compare(password, hash)

package/src/library/error.lib.js

@@ -0,0 +1,11 @@
+class AppError extends Error {
+    constructor({ message, data, statusCode }) {
+        super(data);
+        this.data = data
+        this.message = message
+        this.statusCode = statusCode;
+        this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
+        this.isOperational = true; // Flag to indicate it's an expected error
+    }
+}
+export default AppError  

package/src/middlewares/errorHandler.middleware.js

@@ -0,0 +1,19 @@
+function globalErrorHandler(err, req, res, next) {
+    let statusCode = err.statusCode || 500;
+    let message = err.message || 'Internal Server Error';
+    let data = err.data || {};
+    console.log(err.name)
+    if (err.name === 'ValidationError') {
+        message = Object.values(err.errors).map(err => err.message);
+        console.error('Validation Errors:', message);
+    } else {
+
+    }
+    res.status(statusCode).json({
+        status: err.status || 'error',
+        message,
+        data
+    });
+}
+
+export default globalErrorHandler

package/src/middlewares/payloadValidation.middleware.js

@@ -0,0 +1,19 @@
+import { schemaLookup } from "../validations/validations.schema.js";
+
+export const validateRequest = (req, res, next) => {
+    const { method, path } = req;
+    console.log(path, method)
+    
+    const schema = schemaLookup[`${method}:${path}`] || Object.keys(schemaLookup).find(key => {
+        const regex = new RegExp(`^${key.split(':')[1].replace(':id', '\\d+')}$`);
+        return regex.test(path) && key.startsWith(method);
+    });
+    if (schema) {
+        const { error } = schema.validate(req.body);
+        if (error) {
+            return res.status(400).json({ message: error.details[0].message });
+        }
+    }
+    next(); // Proceed to the next middleware or route handler
+};
+

package/src/models/auth.models.js

@@ -0,0 +1,63 @@
+import mongoose from "mongoose";
+import { VerificationDetailsSchema } from "./common.schema.js";
+import { comparePassword, hashPassword } from "../library/auth.lib.js";
+import AppError from "../library/error.lib.js";
+
+const LoginSchema = mongoose.Schema({
+    email: {
+        type: String,
+        unique: true,
+        trim: true,
+        required: [true, 'Email is required'],
+        match: [/.+@.+\..+/, 'Please enter a valid email address'],
+        lowercase: true,
+    },
+    phone: {
+        type: Number,
+        trim: true,
+        required: false,
+        min: 10
+    },
+    password: {
+        type: String,
+        trim: true,
+        required: [true, 'Password is required'],
+        minlength: [6, 'Password must be at least 6 characters long'],
+    },
+    email_verification_Details: VerificationDetailsSchema,
+    phone_verification_Details: VerificationDetailsSchema
+}, {
+    timestamps: true
+});
+
+LoginSchema.pre('save', async function (next) {
+    this.password = await hashPassword(this.password)
+    next();
+});
+
+LoginSchema.post(['find', 'findOne'], async function (docs) {
+    const _includePassword = this.options.includePassword
+    if (_includePassword) {
+        return docs
+    }
+    if (Array.isArray(docs)) {
+        docs.forEach(doc => {
+            doc.password = undefined; // Remove password from each document
+        });
+    } else if (docs) {
+        docs.password = undefined; // Remove password from the single document
+    }
+});
+
+LoginSchema.statics.isUserAuthenticated = async function (email, password) {
+    let user = await this.findOne({ email }).setOptions({ includePassword: true });
+    if (!user) {
+        throw new AppError({ message: 'User Not Found !', statusCode: 401 })
+    }
+    const isMatch = await comparePassword(password, user.password)
+    if (!isMatch) throw new AppError({ message: 'Incorrect password', statusCode: 400 })
+    return isMatch
+}
+
+const Login = mongoose.model("Loginsf", LoginSchema);
+export default Login;

package/src/models/common.schema.js

@@ -0,0 +1,10 @@
+import mongoose from "mongoose";
+
+export const VerificationDetailsSchema = mongoose.Schema({
+    status: {
+        type: Boolean,
+        default: false, 
+    },
+}, {
+    timestamps: true  
+});

package/src/models/user.models.js

@@ -0,0 +1,30 @@
+import mongoose from "mongoose";
+
+const userSchema = mongoose.Schema({
+    firstName:{
+        type:String,
+        required:true,
+        trim:true
+    },
+    lastName:{
+        type:String,
+        trim:true
+    },
+    LastUpdatedAt:{
+        type: Date,
+        default: Date.now, 
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now, 
+    },
+    gender: {
+        type: String,
+        enum: ['male', 'female'], // Enum values for gender
+        required: true,
+    },
+})
+
+
+const user = mongoose.model('customerUser', userSchema);
+export default user;

package/src/routes/auth.routes.js

@@ -0,0 +1,30 @@
+import express from 'express';
+import { register, login } from '../controllers/auth.controller.js';
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /auth/register:
+ *   post:
+ *     summary: Register a new user
+ *     responses:
+ *       200:
+ *         description: User registered successfully.
+ *       400:
+ *         description: Bad request
+ */
+router.post('/register', register);
+
+/**
+ * @swagger
+ * /auth/login:
+ *   post:
+ *     summary: User login
+ *     responses:
+ *       200:
+ *         description: User logged in successfully.
+ */
+router.post('/login', login);
+
+export default router;

package/src/routes/business.routes.js

@@ -0,0 +1,5 @@
+import express from 'express'
+
+export const app = express()
+
+app.post('/',login)

package/src/routes/public.routes.js

@@ -0,0 +1,2 @@
+
+

package/src/server.js

@@ -0,0 +1,13 @@
+import app from "./app.js"
+
+import globalErrorHandler from "./middlewares/errorHandler.middleware.js";
+const PORT = process.env.PORT || 3000;
+const ENV = process.env.NODE_ENV
+
+
+app.use(globalErrorHandler)
+
+
+app.listen(PORT, () => {
+    console.log(`Server is running on http://localhost:${PORT} at ${ENV}`);
+});

package/src/validations/validations.schema.js

@@ -0,0 +1,53 @@
+import Joi from 'joi';
+
+// Define your schemas (same as before)
+const userSchema = Joi.object({
+    email: Joi.string()
+        .email()
+        .optional()
+        .messages({
+            'string.email': 'Please enter a valid email address',
+        }),
+    phone: Joi.number()
+        .optional()
+        .min(1000000000)
+        .max(9999999999)
+        .messages({
+            'number.min': 'Phone number must be at least 10 digits',
+            'number.max': 'Phone number must be at most 10 digits',
+        }),
+    password: Joi.string()
+        .min(6)
+        .optional()
+        .pattern(/^[a-zA-Z0-9]{3,30}$/)
+        .messages({
+            'string.min': 'Password must be at least 6 characters long',
+            'string.pattern.base': 'Password can only contain alphanumeric characters',
+        }),
+}).xor('email', 'phone')
+  .messages({
+      'object.xor': 'Either email or phone number must be provided.',
+  });
+
+// Schema configuration mapping
+const schemaConfig = [
+    {
+        methods: ['POST', 'PUT'],
+        paths: ['/auth/login', '/users/:id'],
+        schema: userSchema,
+    },
+    // Add more route configurations as needed
+];
+
+// Preprocess the schema configuration into a lookup map
+const schemaLookup = {};
+
+schemaConfig.forEach(route => {
+    route.methods.forEach(method => {
+        route.paths.forEach(path => {
+            schemaLookup[`${method}:${path}`] = route.schema;
+        });
+    });
+});
+
+export { schemaLookup, userSchema };

package/start.js

@@ -0,0 +1,11 @@
+// start.mjs
+import  register  from '@babel/register';
+
+register({
+    extensions: ['.js', '.mjs'], // Specify the extensions you want Babel to transpile
+});
+
+import('./src/server.js').catch(err => {
+    console.error(err);
+    process.exit(1);
+});