nodejs-backpack 0.0.1-security → 2.0.5

package/.sample-env

@@ -0,0 +1,3 @@
+PORT=3000
+DB="mongodb+srv://USERNAME:PASSWORD@mongo.9bdgpey.mongodb.net/node_backpack"
+JWT_SIGNATURE=node_backpack

package/helper.js

@@ -0,0 +1,76 @@
+const fs = require("fs");
+
+function convertToKebabCase(string) {
+  // Convert the first character to lowercase
+  string = string.charAt(0).toLowerCase() + string.slice(1);
+
+  // Add a hyphen before each uppercase letter
+  string = string.replace(/([A-Z])/g, "-$1").toLowerCase();
+
+  return string;
+}
+function loadSchemaFromFile(filePath) {
+  // Load the model from the file path
+  const model = require(filePath);
+  // Access the schema from the model
+  const schema = model.schema;
+  return schema;
+}
+
+function searchableFields(Model) {
+  var formFields = modelsParams(Model);
+  var uploadFieldArray = [];
+  var searchFields = [];
+  if (
+    formFields &&
+    formFields?.filteredFormFields &&
+    formFields?.filteredFormFields.length
+  ) {
+    searchFields = formFields?.filteredFormFields;
+    return searchFields;
+  }
+}
+
+function modelsParams(Schema) {
+  // Obtain the schema parameters object
+  const paths = Schema.paths;
+  let parameters = [];
+  let all = [];
+  let required = [];
+  let optional = [];
+  // Loop over the paths and log each field's name and type
+  for (const path in paths) {
+    let isRequired = paths[path]?.options?.required ? true : false;
+    parameters.push({
+      field: path,
+      is_required: isRequired,
+    });
+    if (isRequired) {
+      required.push(path);
+    } else {
+      optional.push(path);
+    }
+    all.push(path);
+  }
+  const unwantedProps = ["_id", "createdAt", "updatedAt", "__v"];
+  const filteredFormData = all.filter((prop) => !unwantedProps.includes(prop));
+  return {
+    parameters: parameters,
+    allFields: all,
+    requiredFields: required,
+    optionalFields: optional,
+    filteredFormFields: filteredFormData,
+  };
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+module.exports = {
+  convertToKebabCase,
+  loadSchemaFromFile,
+  modelsParams,
+  capitalize,
+  searchableFields,
+};

package/index.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+const fs=require("fs-extra"),path=require("path");var clc=require("cli-color");const{loadSchemaFromFile,modelsParams,capitalize,searchableFields}=require("./helper"),command=process.argv[2],fileName=process.argv[3];if("sample:files"===command){const a=process.cwd(),b=path.join(a,"sample-app.js");let e=fs.readFileSync(path.join(__dirname,"sample-app.js"),"utf8");fs.writeFileSync(b,e);const d=path.join(a,".sample-env");let s=fs.readFileSync(path.join(__dirname,".sample-env"),"utf8");fs.writeFileSync(d,s);const f=path.join(a,"sample-package.json");let i=fs.readFileSync(path.join(__dirname,"sample-package.json"),"utf8");fs.writeFileSync(f,i),console.log(clc.green('"sample-app.js", "sample-package.json" & ".sample-env" file created in the root directory.'))}else if("make:schema"===command){const h=process.cwd(),i=path.join(h,"models"),j=(fs.existsSync(i)||fs.mkdirSync(i),path.join(i,fileName+".js"));let e=fs.readFileSync(path.join(__dirname,"sample-schema.js"),"utf8");e=e.replace(/\${fileContent}/g,fileName);const l=fileExists(j);l?console.error(clc.bgRed(`
+'models/${fileName}.js' file already exist!, Kindly delete existing and try again.`)):(fs.writeFileSync(j,e),console.log(clc.green(`
+'models/${fileName}.js' file created!`)))}else if("make:apis"===command){const m=process.argv.find(e=>e.startsWith("--url=")),n=process.argv.find(e=>e.startsWith("--schema=")),o=(-1===m&&-1===n||void 0===m&&void 0===n?(console.error(clc.bgRed("Missing parameters. Please provide --url=<api_url> and --schema=<schema_name>.")),process.exit(1)):-1===m||void 0===m?(console.error(clc.bgRed("Missing parameters. Please provide --url=<api_url>.")),process.exit(1)):-1!==n&&void 0!==n||(console.error(clc.bgRed("Missing parameters. Please provide --schema=<schema_name>.")),process.exit(1)),m.split("=")[1]),p=n.split("=")[1],q=process.cwd(),r=path.join(q,"models",p+".js"),s=(fs.existsSync(r)||(console.error(clc.bgRed(`Schema file "${p}.js" does not exist in '/models/${p}.js'.`)),process.exit(1)),path.join(q,"routes")),t=path.join(q,"helpers"),u=path.join(s,"validationRequest"),v=path.join(u,""+fileName),w=path.join(q,"controllers");fs.existsSync(s)||fs.mkdirSync(s),fs.existsSync(u)||fs.mkdirSync(u),fs.existsSync(v)||fs.mkdirSync(v),fs.existsSync(w)||fs.mkdirSync(w),fs.existsSync(t)||fs.mkdirSync(t),controllerFileCreate(w,fileName,p),indexRouteFileCreate(s,fileName),validationFileCreate(r,p,v),newRouteFileCreate(s,fileName,o,p),helperFileCreate(t)}else if("make:auth"===command){const z=process.cwd(),A=path.join(z,"middleware"),B=(fs.existsSync(A)||fs.mkdirSync(A),path.join(z,"routes")),C=(fs.existsSync(B)||fs.mkdirSync(B),path.join(z,"controllers")),D=(fs.existsSync(C)||fs.mkdirSync(C),path.join(z,"config")),E=(fs.existsSync(D)||fs.mkdirSync(D),path.join(z,"models"));fs.existsSync(E)||fs.mkdirSync(E),authMiddlewareFileCreate(A),authRouteFileCreate(B),authControllersFileCreate(C),authConfigFileCreate(D),authSchemaFileCreate(E)}else console.error(clc.bgRed("Unknown command: "+command));async function indexRouteFileCreate(e,s){e=path.join(e,"IndexRoute.js");try{await fileExists(e)||(i=fs.readFileSync(path.join(__dirname,"sample-index-route.js"),"utf8"),fs.writeFileSync(e,i),console.log(clc.green("\nIndexRoute.js file created successfully!"))),data=await readFile(e,"utf8");var i,a=`router.use("/", ${s}Route);`,r=(updateIndexFile(e,a,data.indexOf("module.exports = router;")),`const ${s}Route = require("./${s}Route");`);updateIndexFile(e,r,data.indexOf("const router = express.Router();"))}catch(e){console.error(e)}}function fileExists(i){return new Promise((s,e)=>{fs.access(i,fs.constants.F_OK,e=>{s(!e)})})}function readFile(e,s){return new Promise((i,a)=>{fs.readFile(e,s,(e,s)=>{e?a(e):i(s)})})}function writeFile(e,a,r){return new Promise((s,i)=>{fs.writeFile(e,a,r,e=>{e?i(e):s()})})}async function updateIndexFile(e,s,i){try{var a=await readFile(e,"utf8");-1===i||a.includes(s)?console.log(clc.yellow(s+" already imported in IndexRoute.js!")):(await writeFile(e,a.slice(0,i)+s+"\n"+a.slice(i),"utf8"),console.log(clc.green(s+" imported into IndexRoute.js successfully!")))}catch(e){console.log(clc.red("An error occurred:",e))}}async function controllerFileCreate(a,r,t){a=path.join(a,r+"Controller.js");if(await fileExists(a))console.log(clc.bgRed(`
+${r}Controller.js file already exist!`));else{let e=fs.readFileSync(path.join(__dirname,"sample-controller.js"),"utf8"),s=(e=(e=e.replace(/\${fileName}/g,r)).replace(/\${schemaName}/g,t),"["),i="{";var l,o=process.cwd(),o=path.join(o,"models",t+".js"),t=loadSchemaFromFile(o),o=searchableFields(t);for(l of o)s+=`
+				{ ${l}: { $regex: searchRgx, $options: "i" } },`,i+=`
+				${l}: (req?.body?.${l}) || null,`;s+=`
+			]`,i+=`
+			}`,0===o.length&&(s+="[{}]"),e=(e=e.replace(/\${___SearchFieldArray___}/g,s)).replace(/\${___StoreFieldArray___}/g,i),fs.writeFileSync(a,e),console.log(clc.green(`
+${r}Controller.js file created successfully in the '/controllers/${r}Controller.js' folder.!`))}}async function validationFileCreate(e,a,r){var e=loadSchemaFromFile(e),e=modelsParams(e),s=[];if(e&&e?.filteredFormFields&&e?.filteredFormFields.length){var i,t=e?.filteredFormFields;for(i in t)t[i]&&s.push({name:t[i]});e?.filteredFormFields}let l="";e?.requiredFields&&0<e?.requiredFields?.length&&e?.requiredFields.forEach(e=>{l+=`
+	check("${e}").custom((value, { req }) => {
+        const fileExists =
+          req.files && req.files.some((obj) => obj.fieldname === "${e}");
+        const ${e}Exists = req.body && req.body.${e};
+    
+        if (fileExists || ${e}Exists) {
+          return true;
+        } else {
+          throw new Error("${capitalize(e)} is required.");
+        }
+      }),`});["List","GetDetail","Store","Update","Destroy"].forEach(async e=>{let s=fs.readFileSync(path.join(__dirname,"sample-validation.js"),"utf8");s=s.replace(/\${schemaName}/g,a);var i=l,i=("GetDetail"===e||"Destroy"===e||"Update"===e?i=`
+	param("id").custom((value, { req }) => {
+        return ${a}.findOne({ _id: value }).then((${a}Data) => {
+          if (!${a}Data) {
+            return Promise.reject("Invalid ID! The provided ID does not exist in the database.");
+          }
+        });
+      }),`:"List"===e&&(i=""),i+=`
+`,s=s.replace(/\__validation__dynamic__code__/g,i),path.join(r,e+"ValidationRequest.js"));await fileExists(i)?console.log(clc.bgRed(e+"ValidationRequest.js file already exist!")):(fs.writeFileSync(i,s),console.log(clc.green(`"${e}ValidationRequest.js" file created in the '/routes/validationRequest/${e}ValidationRequest.js' folder.`)))})}async function newRouteFileCreate(s,i,a,r){s=path.join(s,i+"Route.js");if(await fileExists(s))console.log(clc.bgRed(`
+${i}Route.js file already exist!`));else{let e=fs.readFileSync(path.join(__dirname,"sample-route.js"),"utf8");e=(e=(e=e.replace(/\${fileName}/g,i)).replace(/\${apiUrl}/g,a)).replace(/\${schemaName}/g,r),fs.writeFileSync(s,e),console.log(clc.green(`"${i}Route.js" file created in the '/routes/${i}Route.js' folders.`))}}async function helperFileCreate(e){var s,i=path.join(e,"helper.js"),i=(await fileExists(i)||(s=fs.readFileSync(path.join(__dirname,"sample-helper.js"),"utf8"),fs.writeFileSync(i,s)),path.join(e,"fileUploader.js")),i=(await fileExists(i)||(s=fs.readFileSync(path.join(__dirname,"sample-file-uploader.js"),"utf8"),fs.writeFileSync(i,s)),path.join(e,"formParser.js"));await fileExists(i)||(s=fs.readFileSync(path.join(__dirname,"sample-form-parser.js"),"utf8"),fs.writeFileSync(i,s))}async function authMiddlewareFileCreate(e){var s,e=path.join(e,"AuthMiddleware.js");await fileExists(e)?console.error(clc.bgRed(`
+AuthMiddleware.js file already exist!`)):(s=fs.readFileSync(path.join(__dirname,"sample-auth-middleware.js"),"utf8"),fs.writeFileSync(e,s))}async function authRouteFileCreate(e){var s=path.join(e,"IndexRoute.js"),i=(await fileExists(s)||(i=fs.readFileSync(path.join(__dirname,"sample-index-route.js"),"utf8"),fs.writeFileSync(s,i),console.log(clc.green("\nIndexRoute.js file created successfully!"))),path.join(e,"AuthRoute.js")),i=(await fileExists(i)?console.error(clc.bgRed(`
+AuthRoute.js file already exist!`)):(e=fs.readFileSync(path.join(__dirname,"sample-auth-route.js"),"utf8"),fs.writeFileSync(i,e)),await updateIndexFile(s,'const AuthRoute = require("./AuthRoute");',(data=await readFile(s,"utf8")).indexOf("const router = express.Router();")),await updateIndexFile(s,'router.use("/", AuthRoute);',(data=await readFile(s,"utf8")).indexOf("module.exports = router;")),process.cwd());logicHelperFileCreate(i),authValidationFileCreate(i)}async function authControllersFileCreate(e,s="Auth"){var i,e=path.join(e,s+"Controller.js");await fileExists(e)?console.log(clc.bgRed(`
+${s}Controller.js file already exist!`)):(i=fs.readFileSync(path.join(__dirname,"sample-auth-controller.js"),"utf8"),fs.writeFileSync(e,i),console.log(clc.green(`
+${s}Controller.js file created successfully in the '/controllers/${s}Controller.js' folder.!`)))}async function authConfigFileCreate(e,s="mailtrap"){var i,e=path.join(e,s+".js");await fileExists(e)?console.log(clc.bgRed(`
+${s}.js file already exist!`)):(i=fs.readFileSync(path.join(__dirname,"sample-config-mailer.js"),"utf8"),fs.writeFileSync(e,i),console.log(clc.green(`
+${s}.js file created successfully in the '/config/${s}.js' folder.!`))),console.log(clc.yellow(`
+Update SMTP credentials in ${s}.js file which is created in the '/config/${s}.js' folder.!`))}async function authSchemaFileCreate(e){var s;for(s of["ResetToken","User"]){var i,a=path.join(e,s+".js");await fileExists(a)?"User"===s?console.log(clc.bgRed(`
+models/${s}.js file already exist! `),clc.yellow(`Please confirm that the 'first_name', 'last_name', 'email', 'password' and 'token' fields exist in the schema and are marked as required. To make the APIs work. Otherwise, delete the models/${s}.js file and try again.
+`)):console.log(clc.bgRed(`
+models/${s}.js file already exist!`)):(i=fs.readFileSync(path.join(__dirname,`sample-schema-${s}.js`),"utf8"),fs.writeFileSync(a,i),console.log(clc.green(`
+models/${s}.js file created successfully in the '/models/${s}.js' folder.!`)))}}async function logicHelperFileCreate(e){e=path.join(e,"helpers");fs.existsSync(e)||fs.mkdirSync(e),helperFileCreate(e)}async function authValidationFileCreate(e){e=path.join(e,"routes"),fs.existsSync(e)||fs.mkdirSync(e),e=path.join(e,"validationRequest");fs.existsSync(e)||fs.mkdirSync(e);const r=path.join(e,"Auth");fs.existsSync(r)||fs.mkdirSync(r),["signUpRequest","signIn","forgotPassword","resetPassword"].forEach(async s=>{var i=path.join(r,s+"ValidationRequest.js");if(await fileExists(i))console.error(clc.bgRed(`
+${s}ValidationRequest.js file already exist!`));else{let e=fs.readFileSync(path.join(__dirname,"sample-validation.js"),"utf8");var a="";"signUpRequest"===s?a+=`
+	body("first_name").notEmpty().withMessage("First Name is required").trim(),
+        
+	body("last_name").notEmpty().withMessage("Last Name is required").trim(),
+        
+	body("email")
+          .notEmpty()
+          .withMessage("Email Address is required")
+          .isEmail()
+          .withMessage("Enter correct email address")
+          .custom((value, { req }) => {
+            return User.findOne({ email: value }).then((userDoc) => {
+              if (userDoc) {
+                return Promise.reject("Email Address already exists!");
+              }
+            });
+          }),
+          
+	body("password")
+          .notEmpty()
+          .withMessage("Password is requierd")
+          .isLength({ min: 6, max: 250 })
+          .withMessage("Minimum 6 character password require")
+          .trim(),`:"signIn"===s?a+=`
+	body("email")
+        .notEmpty()
+        .withMessage("Email Address is required")
+        .isEmail()
+        .withMessage("Enter correct email address")
+        .custom((value, { req }) => {
+          return User.findOne({ email: value }).then((userDoc) => {
+            if (!userDoc) {
+              return Promise.reject("A user with this email could not be found!");
+            }
+          });
+        }),
+      
+	body("password")
+        .notEmpty()
+        .withMessage("Password is requierd")
+        .isLength({ min: 6, max: 250 })
+        .withMessage("Minimum 6 character password require")
+        .trim()`:"forgotPassword"===s?a+=`
+	body("email")
+        .notEmpty()
+        .withMessage("Email Address is required")
+        .isEmail()
+        .withMessage("Enter correct email address")
+        .custom((value, { req }) => {
+          return User.findOne({ email: value }).then((userDoc) => {
+            if (!userDoc) {
+              return Promise.reject("A user with this email could not be found!");
+            }
+          });
+        }),`:"resetPassword"===s&&(a+=`
+	body("email")
+        .notEmpty()
+        .withMessage("Email Address is required")
+        .isEmail()
+        .withMessage("Enter correct email address")
+        .custom((value, { req }) => {
+          return User.findOne({ email: value }).then((userDoc) => {
+            if (!userDoc) {
+              return Promise.reject("A user with this email could not be found!");
+            }
+          });
+        }),
+    
+        
+	body("reset_token").notEmpty().withMessage("Reset token is required").trim(),
+    
+        
+	body("password")
+        .notEmpty()
+        .withMessage("Password is required")
+        .isLength({ min: 6, max: 250 })
+        .withMessage("Minimum 6 character password require")
+        .trim(),
+    
+        
+	body("confirm_password")
+        .notEmpty()
+        .withMessage("Confirm password is required")
+        .custom((val, { req }) => {
+          if (req.body.password !== val) {
+            throw new Error("Confirm password does not match");
+          }
+          return true;
+        }),`),a+=`
+`,e=(e=e.replace(/\${schemaName}/g,"User")).replace(/\__validation__dynamic__code__/g,a),fs.writeFileSync(i,e)}})}

package/package.json

@@ -1,6 +1,53 @@
-{
-  "name": "nodejs-backpack",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+{
+  "name": "nodejs-backpack",
+  "version": "2.0.5",
+  "description": "NodeJs Backpack is a powerful tool designed to simplify the development of Node.js REST APIs with ease and precision. It provides a streamlined workflow by automatically generating Mongoose schemas and handling the necessary configurations in your project. With just a few simple commands, NodeJs Backpack can create REST API components such as controllers and routes, while also ensuring route validation is implemented flawlessly. Additionally, NodeJs Backpack offers a command to generate sample files, providing a solid starting point for your project. With NodeJs Backpack, you can quickly set up your project and focus on building your APIs, letting the tool handle the repetitive tasks and allowing you to follow a smooth development process.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "uglifyjs -c -m -o publish_package_code/index.js index.js"
+  },
+  "keywords": [
+    "cli",
+    "CRUD Functionality",
+    "REST APIs",
+    "Files",
+    "Routing",
+    "Controllers",
+    "Models",
+    "Mongoose",
+    "jsonwebtoken",
+    "Authentication",
+    "JWT",
+    "Validation",
+    "Automation",
+    "Backpack",
+    "npm",
+    "node",
+    "node cli",
+    "node js",
+    "Node Js Project Builder",
+    "Project Builder",
+    "nodejs-backpack",
+    "jkg",
+    "jaykumar-gohil"
+  ],
+  "author": "",
+  "license": "CC BY-NC-ND 4.0",
+  "dependencies": {
+    "cli-color": "^2.0.3",
+    "express": "^4.18.2",
+    "express-validator": "^7.0.1",
+    "jsonwebtoken": "^9.0.1",
+    "fs-extra": "^11.1.1",
+    "mongoose": "^7.3.1",
+    "mongoose-backpack": "^0.2.7",
+    "rest-api-response-npm": "^0.1.4"
+  },
+  "devDependencies": {
+    "uglify-js": "^3.17.4"
+  },
+  "bin": {
+    "nodejs-backpack": "./index.js"
+  }
+}

package/readme.md

@@ -0,0 +1,151 @@
+# NodeJs Backpack
+
+NodeJs Backpack is a powerful tool designed to simplify the development of Node.js REST APIs with ease and precision. It provides a streamlined workflow by automatically generating Mongoose schemas and handling the necessary configurations in your project.
+
+With just a few simple commands, NodeJs Backpack can create REST API components such as controllers and routes, while also ensuring route validation is implemented flawlessly. Additionally, NodeJs Backpack offers a command to generate sample files, providing a solid starting point for your project.
+
+With NodeJs Backpack, you can quickly set up your project and focus on building your APIs, letting the tool handle the repetitive tasks and allowing you to follow a smooth development process.
+
+## Installation
+
+Install package globally with npm
+
+```bash
+  npm install nodejs-backpack -g
+```
+
+## Features
+
+- Robust REST APIs
+- Focus on optimized code
+- Auto file creation for schemas, routes, controllers and validations
+- helpers (modelsParams, appendParams, etc)
+- Mongoose DB support,
+- AppendParams for append data in APIs using Mongoose schema
+- Executable for generating applications quickly
+- Auto create logic for API CRUD
+
+## Quick Start (Rest APIs)
+
+The quickest way to get started with nodejs-backpack is to utilize the executable to generate an REST APIs as shown below:
+
+**Step1:** Create an empty directory:
+
+```bash
+mkdir NodeJs-REST-APIs
+```
+
+**Step2:** Enter into directory:
+
+```bash
+cd NodeJs-REST-APIs
+```
+
+**Step3:** Run Command:
+
+```bash
+nodejs-backpack sample:files
+```
+
+- File "`sample-app.js`", "`sample-package.json`" & "`.sample-env`" created in the root directory.
+- **Rename sample files** to "**`app.js`**", "**`package.json`**" & "**`.env`**" which are created in the root directory.
+
+  ![](https://github.com/GohilJaykumar/sharable/blob/main/typing.gif)
+
+- Update .env > **`DB=mongodb+srv...`** with valid connection.
+
+```bash
+PORT=3000
+DB="mongodb+srv://........mongodb.net/node_backpack"
+JWT_SIGNATURE=node_backpack
+HOST=http://localhost:3000
+```
+
+**Step4:** Run Command:
+
+```bash
+npm install
+```
+
+**Step5:** Run Command:
+
+```bash
+nodejs-backpack make:schema Tests
+```
+
+**Step6:** Run Command:
+
+```bash
+nodejs-backpack make:apis Test --url=tests --schema=Tests
+```
+
+- Rename schema name in comand as per your requirement **_nodejs-backpack make:apis Test --url=tests --schema=Tests_**.
+- Example: _nodejs-backpack make:apis **ROUTE_NAME** --url=**ROUTE_URL** --schema=**SCHEMA_NAME**_.
+- **Note:** _`SCHEMA_NAME` must exist in model directory `/models/SCHEMA_NAME`_
+
+**Step7:** Install 'nodemon' on global level for development purpose:
+
+```bash
+npm install nodemon -g
+```
+
+**Step8:** Now your APIs are ready to use and Server your project with:
+
+```bash
+npm run dev
+```
+
+**Step9:** Open Postman and create new collection and check the below apis:
+
+- Based on my command,
+  **_nodejs-backpack make:apis `Test` --url=`tests` --schema=`Tests`_**.
+- ROUTE_NAME = `Test`
+- ROUTE_URL = `tests`
+- SCHEMA_NAME = `Tests`
+- Below are list of APIs created by commands `.../api/ROUTE_URL`:
+- _**Get List API**_: **`GET:`** _`http://localhost:3000/api/tests?page_no=1&page_limit=20&search=` (Parameters: page_no, page_limit, search)_
+- _**Get Detail API**_: **`GET:`** _`http://localhost:3000/api/tests/64a41036174844d0394e7b2f`_
+- _**Store API**_: **`POST:`** _`http://localhost:3000/api/tests` (Body-Parameters: based on model schema)_
+- _**Update API**_: **`PUT:`** _`http://localhost:3000/api/tests/64a41036174844d0394e7b2f` (Body-Parameters: based on model schema)_
+- _**Delete API**_: **`DELETE:`** _`http://localhost:3000/api/tests/64a41036174844d0394e7b2f`_
+
+## Quick Start (Authentication APIs)
+
+The quickest way to get started with **signup**, **register**, **forgot-password**, **reset-password**, **get-profile** API's using nodejs-backpack is to utilize the executable to generate an REST APIs as shown below:
+
+**Step1:** Run Command:
+
+```bash
+nodejs-backpack make:auth
+```
+
+- Under **./routes/\*** '**IndexRoute.js**' and '**AuthRoute.js**' file will be create/updated.
+- '**AuthController.js**' file will be create in the '**./controllers/AuthController.js**' folder with all neccessary logics.
+- '**AuthMiddleware.js**' file will be create in the '**./middleware/AuthMiddleware.js**' folder with all neccessary JWT token verification logics.
+- mailtrap.js file will be create in the '**./config/mailtrap.js**' folder where you can configure SMTP mail credentials.
+- Under **./models/\*** '**User.js**' and '**ResetToken.js**' file will be create.
+
+**Step2:** Open Postman and create new collection and check the below apis:
+
+- Below are list of APIs created by commands `.../api/ROUTE_URL`:
+- _**Register API**_: **`POST:`** _`http://localhost:3000/api/register` (Body-Parameters: first_name, last_name, email, password)_
+- _**Login API**_: **`POST:`** _`http://localhost:3000/api/login` (Body-Parameters: email, password)_
+- _**Forgot Password API**_: **`POST:`** _`http://localhost:3000/api/forgot-password` (Body-Parameters: email)_
+- _**Reset Password API**_: **`POST:`** _`http://localhost:3000/api/reset-password` (Body-Parameters: email, password, reset_token)_. **Note**: Forgot password reset link will contain '**reset_token**' on mail.
+- _**Logout API**_: **`GET:`** _`http://localhost:3000/api/logout`_
+- _**Get Profile API**_: **`GET:`** _`http://localhost:3000/api/get-profile`_
+
+## Environment Variables
+
+To run this project, you will need to add the following environment variables to your .env file
+
+```bash
+PORT=3000
+DB="mongodb+srv://........mongodb.net/node_backpack"
+JWT_SIGNATURE=node_backpack
+HOST=http://localhost:3000
+```
+
+## Authors
+
+- Jaykumar Gohil ([@jksk21](https://www.npmjs.com/~jksk21))

package/sample-app.js

@@ -0,0 +1,41 @@
+const express = require("express");
+const app = express();
+const routes = require("./routes/IndexRoute");
+const dotenv = require("dotenv").config().parsed;
+const mongoose = require("mongoose");
+const { catchError } = require("rest-api-response-npm");
+
+app.use((req, res, next) => {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader(
+    "Access-Control-Allow-Methods",
+    "OPTIONS, GET, POST, PUT, PATCH, DELETE"
+  );
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  next();
+});
+
+// Routes
+app.use("/api", routes);
+
+// default error messgae
+app.use((error, req, res, next) => {
+  catchError(res, error);
+  console.error(error);
+});
+
+// Serve files from the 'public' directory
+app.use(express.static("public"));
+
+// Start server mongooes and port
+mongoose
+  .connect(dotenv.DB)
+  .then((result) => {
+    const port = dotenv.PORT;
+    app.listen(port, () => {
+      console.log(`Server started on port http://localhost:${port}`);
+    });
+  })
+  .catch((err) => {
+    console.log(err);
+  });

package/sample-auth-controller.js

@@ -0,0 +1,217 @@
+const User = require("../models/User"); //
+const ResetToken = require("../models/ResetToken");
+const bcrypt = require("bcryptjs");
+const jwt = require("jsonwebtoken");
+const dotenv = require("dotenv").config().parsed;
+const crypto = require("crypto");
+const {
+  successResponse,
+  checkValidationResult,
+  customResponse,
+  errorResponse,
+} = require("rest-api-response-npm");
+const nodemailer = require("../config/mailtrap");
+
+const AuthController = {
+  signUp: (req, res, next) => {
+    const response = checkValidationResult(res, req);
+    if (response["status_code"] === 422) {
+      return errorResponse(
+        res,
+        response["data"],
+        response["message"],
+        response["status_code"]
+      );
+    }
+    const password = req.body.password;
+    bcrypt
+      .hash(password, 12)
+      .then((hashPw) => {
+        req.body.password = hashPw;
+        const user = new User(req.body);
+        return user.save();
+      })
+      .then((result) => {
+        return successResponse(res, result, "User Registerd Successfully");
+      })
+      .catch((err) => {
+        next(err);
+      });
+  },
+  login: (req, res, next) => {
+    const response = checkValidationResult(res, req);
+    if (response["status_code"] === 422) {
+      return errorResponse(
+        res,
+        response["data"],
+        response["message"],
+        response["status_code"]
+      );
+    }
+    const email = req.body.email;
+    const password = req.body.password;
+    let loadedUser;
+    User.findOne({ email: email })
+      .then((user) => {
+        loadedUser = user;
+        return bcrypt.compare(password, user.password);
+      })
+      .then((isEqual) => {
+        if (!isEqual) {
+          data = {
+            password: ["Wrong Password"],
+          };
+          return customResponse(res, data, "Wrong Password", 422);
+        }
+        // create new token using sign
+        return jwt.sign(
+          {
+            userId: loadedUser._id,
+          },
+          dotenv.JWT_SIGNATURE,
+          { expiresIn: "365d" }
+        );
+      })
+      .then((token) => {
+        loadedUser.token = token;
+        loadedUser.save();
+        return successResponse(
+          res,
+          { access_token: token, user_data: loadedUser },
+          "Login Successfully"
+        );
+      })
+      .catch((err) => {
+        next(err);
+      });
+  },
+  logout: (req, res, next) => {
+    const filter = { _id: req.userId };
+    const update = { token: "" };
+    User.findOneAndUpdate(filter, update)
+      .then(() => {
+        return successResponse(res, null, "You have been Logged Out");
+      })
+      .catch((err) => {
+        next(err);
+      });
+  },
+  forgotPassword: (req, res, next) => {
+    const response = checkValidationResult(res, req);
+    if (response["status_code"] === 422) {
+      return errorResponse(
+        res,
+        response["data"],
+        response["message"],
+        response["status_code"]
+      );
+    }
+    crypto.randomBytes(32, (err, buffer) => {
+      if (err) {
+        return customResponse(res, null, "Something went wrong", 400);
+      }
+      const token = buffer.toString("hex");
+      User.findOne({ email: req.body.email })
+        .then((user) => {
+          const reset_token = new ResetToken({
+            reset_token: token,
+            email: user.email,
+          });
+          return reset_token.save();
+        })
+        .then((result) => {
+          nodemailer.sendMail({
+            to: req.body.email,
+            from: "ats@technomarktest.io",
+            subject: "Password reset",
+            html: `
+            <p>You requested a password reset</p>
+            <p>Click this <a href="${dotenv?.HOST}/reset/?token=${token}&email=${req.body.email}">link</a> to set a new password.</p>
+          `,
+          });
+          return successResponse(
+            res,
+            null,
+            "Reset password link send your registerd email address"
+          );
+        })
+        .catch((err) => {
+          next(err);
+        });
+    });
+  },
+  resetPassword: (req, res, next) => {
+    const response = checkValidationResult(res, req);
+    if (response["status_code"] === 422) {
+      return errorResponse(
+        res,
+        response["data"],
+        response["message"],
+        response["status_code"]
+      );
+    }
+    const new_password = req.body.password;
+    const r_token = req.body.reset_token;
+    const email = req.body.email;
+    let resetUser;
+    ResetToken.findOne({
+      email: email,
+      reset_token: r_token,
+    })
+      .then((result) => {
+        if (!result) {
+          return customResponse(
+            res,
+            null,
+            `Reset token has expired. Please try the 'forgot password' option again to get a new reset token!`,
+            401
+          );
+        }
+        return User.findOne({
+          email: email,
+        });
+      })
+      .then((user) => {
+        resetUser = user;
+        return bcrypt.hash(new_password, 12);
+      })
+      .then((hashedPassword) => {
+        resetUser.password = hashedPassword;
+        return resetUser.save();
+      })
+      .then((result1) => {
+        return ResetToken.findOneAndDelete({
+          email: email,
+          reset_token: r_token,
+        });
+      })
+      .then((result1) => {
+        return successResponse(res, null, "Your Password Change Successfully");
+      })
+      .catch((err) => {
+        next(err);
+      });
+  },
+  profile: (req, res, next) => {
+    const usertoken = req.headers.authorization;
+    const token = usertoken.split(" ");
+    const user = jwt.verify(token[1], dotenv.JWT_SIGNATURE);
+    User.findOne({ _id: user.userId })
+      .then((userData) => {
+        if (!userData) {
+          return customResponse(
+            res,
+            null,
+            "A user with this email could not be found",
+            400
+          );
+        }
+        return successResponse(res, userData);
+      })
+      .catch((err) => {
+        next(err);
+      });
+  },
+};
+
+module.exports = AuthController;

package/sample-auth-middleware.js

@@ -0,0 +1,44 @@
+const jwt = require("jsonwebtoken");
+const dotenv = require("dotenv").config().parsed;
+const User = require("../models/User"); //
+const { customResponse } = require("rest-api-response-npm");
+
+function authenticateToken(req, res, next) {
+  const authHeader = req.headers["authorization"];
+
+  if (authHeader) {
+    const token = authHeader.split(" ")[1];
+
+    if (token) {
+      try {
+        const jwt_secret_key = dotenv?.JWT_SIGNATURE;
+        const decoded = jwt.verify(token, jwt_secret_key);
+        // Token is valid, you can access the decoded payload
+        console.log("decoded?.data?.token", decoded?.userId);
+        if (decoded?.userId) {
+          User.findOne({ _id: decoded?.userId })
+            .then((userData) => {
+              console.log("token", token);
+              console.log("userData", userData);
+              if (userData && token === userData?.token) {
+                req.user = decoded.data;
+                req.userId = decoded.userId;
+                next();
+              } else {
+                return customResponse(res, null, "Token is expired", 401);
+              }
+            })
+            .catch((err) => {});
+        }
+      } catch (err) {
+        return customResponse(res, null, "Token is invalid or expired", 401);
+      }
+    } else {
+      return customResponse(res, null, "No token found", 401);
+    }
+  } else {
+    return customResponse(res, null, "No authorization header", 401);
+  }
+}
+
+module.exports = authenticateToken;

package/sample-auth-route.js

@@ -0,0 +1,19 @@
+const express = require('express');
+const router = express.Router();
+const AuthController = require('../controllers/AuthController');
+const signUpRequestValidationRequest = require('./validationRequest/Auth/signUpRequestValidationRequest');
+const signInValidationRequest = require('./validationRequest/Auth/signInValidationRequest');
+const forgotPasswordValidationRequest = require('./validationRequest/Auth/forgotPasswordValidationRequest');
+const resetPasswordValidationRequest = require('./validationRequest/Auth/resetPasswordValidationRequest');
+const formParser = require('../helpers/formParser');
+const isAuth = require("../middleware/AuthMiddleware");
+
+
+router.post(`/register`,formParser,signUpRequestValidationRequest, AuthController.signUp);
+router.post(`/login`,formParser,signInValidationRequest, AuthController.login);
+router.post(`/forgot-password`,formParser,forgotPasswordValidationRequest, AuthController.forgotPassword);
+router.post(`/reset-password`,formParser,resetPasswordValidationRequest, AuthController.resetPassword);
+router.get(`/logout`,formParser,isAuth, AuthController.logout);
+router.get(`/get-profile`,formParser,isAuth, AuthController.profile);
+
+module.exports = router;

package/sample-config-mailer.js

@@ -0,0 +1,10 @@
+const nodemailer = require("nodemailer");
+module.exports = defaultExport = nodemailer.createTransport({
+  service: "mailtrap",
+  host: "sandbox.smtp.mailtrap.io",
+  port: 2525,
+  auth: {
+    user: "1f60b50#########",
+    pass: "f0dfc61#########",
+  },
+});

package/sample-controller.js

@@ -0,0 +1,173 @@
+const {
+  successResponse,
+  checkValidationResult,
+  errorResponse,
+} = require("rest-api-response-npm");
+const ${schemaName} = require("../models/${schemaName}");
+const {
+  generatePaginationLinks,
+  searchableFields,
+  mergerFilesAndBody,
+  filterMissingFields,
+} = require("../helpers/helper.js");
+
+const ${fileName}Controller = {
+    list: async (req, res) => {
+      var currentPage = parseInt(req?.query?.page_no) || 1;
+      var perPage = parseInt(req?.query?.page_limit) || 10;
+      var searchInput = req?.query?.search || "";
+      
+      const rgx = (pattern) => new RegExp(`.*${pattern}.*`);
+      const searchRgx = rgx(searchInput);
+      
+      var SearchFieldArray = ${___SearchFieldArray___};
+
+      const count = await ${schemaName}.countDocuments({
+        $or: SearchFieldArray,
+      });
+
+      const totalPages = Math.ceil(count / perPage);
+
+      await ${schemaName}.find({
+        $or: SearchFieldArray,
+      })
+        .skip((currentPage - 1) * perPage)
+        .limit(perPage)
+        .then((results) => {
+          const response = {
+            totalRecords: count,
+            totalPages: totalPages,
+            currentPage: currentPage,
+            perPage: perPage,
+            results: results,
+          };
+
+          generatePaginationLinks(
+            req,
+            response,
+            currentPage,
+            perPage,
+            totalPages,
+            searchInput
+          );
+          return successResponse(
+            res,
+            response,
+            "${fileName} list fetched successfully!"
+          );
+        })
+        .catch((err) => {
+          return errorResponse(res, err, "Opps something went wrong!", 500);
+        });
+    },
+    getDetail: async (req, res) => {
+      const response = checkValidationResult(res, req);
+      if (response["status_code"] === 422) {
+        return errorResponse(
+          res,
+          response["data"],
+          response["message"],
+          response["status_code"]
+        );
+      }
+      await ${schemaName}.findById(req.params.id)
+        .then((result) => {
+          if (result) {
+            return successResponse(res, result, "${fileName} detail fetched successfully!");
+          } else {
+            data = {
+              id: ["Record doesn't exist!"],
+            };
+            return validationResponse(res, data, "Record doesn't exist!");
+          }
+        })
+        .catch((err) =>
+          {
+            return errorResponse(res, err, "Opps something went wrong!", 500)
+          }
+        );
+    },
+    store: async (req, res) => {
+      const response = checkValidationResult(res, req);
+      if (response["status_code"] === 422) {
+        return errorResponse(
+          res,
+          response["data"],
+          response["message"],
+          response["status_code"]
+        );
+      }
+      /*File values into body*/
+      mergerFilesAndBody(req);
+      var storeData = ${___StoreFieldArray___};
+      var ${schemaName}Store = new ${schemaName}(storeData);
+      await ${schemaName}Store.save()
+        .then((result) => {
+          return successResponse(res, result, "${fileName} created successfully!");
+        })
+        .catch((err) => {
+          return errorResponse(res, err, "Opps something went wrong!", 500);
+        });
+    },
+    update: async (req, res) => {
+      const response = checkValidationResult(res, req);
+      if (response["status_code"] === 422) {
+        return errorResponse(
+          res,
+          response["data"],
+          response["message"],
+          response["status_code"]
+        );
+      }
+      /*File values into body*/
+      mergerFilesAndBody(req);
+
+      var updateData = ${___StoreFieldArray___};
+
+      updateData = filterMissingFields(updateData); // Removes fields with null values
+
+      await ${schemaName}.findByIdAndUpdate(req.params.id, updateData, { new: true })
+          .then((result) => {
+            if (result) {
+              successResponse(res, result, "${fileName} updated successfully!");
+            } else {
+              data = {
+                id: ["Record doesn't exist!"],
+              };
+              validationResponse(res, data, "Record doesn't exist!");
+            }
+          })
+          .catch((err) =>
+            errorResponse(res, err, "Opps something went wrong!", 500)
+          );
+    },
+    destroy: async (req, res) => {
+      const response = checkValidationResult(res, req);
+      if (response["status_code"] === 422) {
+        return errorResponse(
+          res,
+          response["data"],
+          response["message"],
+          response["status_code"]
+        );
+      }
+      await ${schemaName}.findByIdAndDelete(req.params.id)
+        .then((result) => {
+          if (result) {
+            return successResponse(res, result, "Deleted successfully!");
+          } else {
+            data = {
+              id: ["Record doesn't exist!"],
+            };
+            return validationResponse(res, data, "Record doesn't exist!");
+          }
+        })
+        .catch((err) =>
+          {
+            return errorResponse(res, err, "Opps something went wrong!", 500)
+          }
+        );
+    }
+  };
+
+  module.exports = ${fileName}Controller;

package/sample-env

@@ -0,0 +1,4 @@
+PORT=3000
+DB="mongodb+srv://USERNAME:PASSWORD@mongo.9bdgpey.mongodb.net/node_backpack"
+JWT_SIGNATURE=node_backpack
+HOST=http://localhost:3000

package/sample-file-uploader.js

@@ -0,0 +1,27 @@
+const multer = require("multer");
+const fs = require("fs");
+const path = require("path");
+
+// Create a Multer instance with destination for uploaded files
+const storage = (routeName) =>
+  multer.diskStorage({
+    destination: function (req, file, cb) {
+      const folder = `./public/${routeName}`;
+
+      // Check if the folder exists, create it if it doesn't
+      if (!fs.existsSync(folder)) {
+        fs.mkdirSync(folder, { recursive: true });
+      }
+
+      cb(null, folder);
+    },
+    filename: function (req, file, cb) {
+      let fileExt = path.extname(file.originalname);
+      cb(null, `${routeName}-${Date.now()}${fileExt}`);
+    },
+  });
+
+// Enable file upload middleware using Multer
+const upload = (routeName) => multer({ storage: storage(routeName) });
+
+module.exports = upload;

package/sample-form-parser.js

@@ -0,0 +1,5 @@
+const multer = require("multer");
+
+let formParser = multer().none();
+
+module.exports = formParser;

package/sample-helper.js

@@ -0,0 +1,138 @@
+function extractRouteName(req) {
+  const path = req.originalUrl.split("?")[0]; // Remove query parameters
+  const parts = path.split("/").filter(Boolean); // Remove empty parts
+  return parts[parts.length - 1];
+}
+
+function generatePaginationLinks(
+  req,
+  response,
+  currentPage,
+  perPage,
+  totalPages,
+  searchInput
+) {
+  const routeName = extractRouteName(req);
+
+  // add first page link
+  const firstLink = `${req.protocol}://${req.get("host")}${
+    req.baseUrl
+  }/${routeName}?page_no=1&page_limit=${perPage}&search=${searchInput}`;
+  response.firstLink = firstLink;
+
+  // add previous page link if exist
+  if (currentPage > 1) {
+    const previousPage = currentPage - 1;
+    const previousLink = `${req.protocol}://${req.get("host")}${
+      req.baseUrl
+    }/${routeName}?page_no=${previousPage}&page_limit=${perPage}&search=${searchInput}`;
+    response.previousLink = previousLink;
+  } else {
+    response.previousLink = null;
+  }
+
+  // add current page link if exist
+  if (currentPage >= 1 || currentPage <= totalPages) {
+    const currentLink = `${req.protocol}://${req.get("host")}${
+      req.baseUrl
+    }/${routeName}?page_no=${currentPage}&page_limit=${perPage}&search=${searchInput}`;
+    response.currentLink = currentLink;
+  } else {
+    response.currentLink = null;
+  }
+
+  // add next page link if exist
+  if (currentPage < totalPages) {
+    const nextPage = currentPage + 1;
+    const nextLink = `${req.protocol}://${req.get("host")}${
+      req.baseUrl
+    }/${routeName}?page_no=${nextPage}&page_limit=${perPage}&search=${searchInput}`;
+    response.nextLink = nextLink;
+  } else {
+    response.nextLink = null;
+  }
+
+  // add last page link
+  const lastPage = totalPages ? totalPages : 1;
+  const lastLink = `${req.protocol}://${req.get("host")}${
+    req.baseUrl
+  }/${routeName}?page_no=${lastPage}&page_limit=${perPage}&search=${searchInput}`;
+  response.lastLink = lastLink;
+
+  return response;
+}
+
+function modelsParams(Schema) {
+  // Obtain the schema parameters object
+  const paths = Schema?.schema?.paths;
+  let parameters = [];
+  let all = [];
+  let required = [];
+  let optional = [];
+  // Loop over the paths and log each field's name and type
+  for (const path in paths) {
+    let isRequired = paths[path]?.options?.required ? true : false;
+    parameters.push({
+      field: path,
+      is_required: isRequired,
+    });
+    if (isRequired) {
+      required.push(path);
+    } else {
+      optional.push(path);
+    }
+    all.push(path);
+  }
+  const unwantedProps = ["_id", "createdAt", "updatedAt", "__v"];
+  const filteredFormData = all.filter((prop) => !unwantedProps.includes(prop));
+  return {
+    parameters: parameters,
+    allFields: all,
+    requiredFields: required,
+    optionalFields: optional,
+    filteredFormFields: filteredFormData,
+  };
+}
+
+function searchableFields(Model) {
+  var formFields = modelsParams(Model);
+  var uploadFieldArray = [];
+  var searchFields = [];
+  if (
+    formFields &&
+    formFields?.filteredFormFields &&
+    formFields?.filteredFormFields.length
+  ) {
+    searchFields = formFields?.filteredFormFields;
+    return searchFields;
+  }
+}
+function mergerFilesAndBody(req) {
+  if (req.files && Object.keys(req.files).length > 0) {
+    Object.keys(req.files).forEach(function (key) {
+      if (req.files[key] && req.files[key] !== undefined) {
+        var file = req.files[key];
+        if (file && file?.path && file?.fieldname)
+          req.body[file?.fieldname] = file?.path.replace(/\public\\/g, "");
+      }
+    });
+    req.files = [];
+    return req;
+  }
+}
+function filterMissingFields(data) {
+  for (var key in data) {
+    if (data[key] === null) {
+      delete data[key];
+    }
+  }
+  return data;
+}
+
+module.exports = {
+  generatePaginationLinks,
+  modelsParams,
+  searchableFields,
+  mergerFilesAndBody,
+  filterMissingFields,
+};

package/sample-index-route.js

@@ -0,0 +1,7 @@
+const express = require("express");
+const router = express.Router();
+// individual-route-module-imported
+
+// defining-api-routes
+
+module.exports = router;

package/sample-package.json

@@ -0,0 +1,29 @@
+{
+  "name": "my-node-project",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "nodemon app.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "body-parser": "^1.20.2",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-validator": "^7.0.1",
+    "jsonwebtoken": "^9.0.1",
+    "mongoose": "^7.3.1",
+    "mongoose-backpack": "^0.2.7",
+    "multer": "^1.4.5-lts.1",
+    "node-backpack": "^0.0.427",
+    "nodemailer": "^6.9.3",
+    "rest-api-response-npm": "^0.1.4"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  }
+}

package/sample-route.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const router = express.Router();
+const ${fileName}Controller = require('../controllers/${fileName}Controller');
+const ListValidationRequest = require('./validationRequest/${fileName}/ListValidationRequest');
+const GetDetailValidationRequest = require('./validationRequest/${fileName}/GetDetailValidationRequest');
+const StoreValidationRequest = require('./validationRequest/${fileName}/StoreValidationRequest');
+const UpdateValidationRequest = require('./validationRequest/${fileName}/UpdateValidationRequest');
+const DestroyValidationRequest = require('./validationRequest/${fileName}/DestroyValidationRequest');
+const upload = require('../helpers/fileUploader');
+const formParser = require('../helpers/formParser');
+
+const prefix = '${apiUrl}';
+
+router.get(`/${prefix}/`,formParser,ListValidationRequest, ${fileName}Controller.list);
+router.get(`/${prefix}/:id`,formParser,GetDetailValidationRequest, ${fileName}Controller.getDetail);
+router.post(`/${prefix}/`,upload(prefix).any(),StoreValidationRequest, ${fileName}Controller.store);
+router.put(`/${prefix}/:id`,upload(prefix).any(),UpdateValidationRequest, ${fileName}Controller.update);
+router.delete(`/${prefix}/:id`,formParser,DestroyValidationRequest, ${fileName}Controller.destroy);
+
+module.exports = router;

package/sample-schema-ResetToken.js

@@ -0,0 +1,26 @@
+const mongoose = require("mongoose");
+const Schema = mongoose.Schema;
+const { appendParams } = require("mongoose-backpack");
+
+const ResetToken = new Schema(
+  {
+    email: {
+      type: String,
+      required: true,
+    },
+    reset_token: {
+      type: String,
+      required: false,
+    },
+  },
+  { timestamps: true }
+);
+
+appendData = {
+  id: function () {
+    return this._id;
+  },
+};
+appendParams(ResetToken, appendData);
+
+module.exports = mongoose.model("ResetToken", ResetToken);

package/sample-schema-User.js

@@ -0,0 +1,51 @@
+const mongoose = require("mongoose");
+const Schema = mongoose.Schema;
+const { appendParams } = require("mongoose-backpack");
+
+const User = new Schema(
+  {
+    first_name: {
+      type: String,
+      required: true,
+    },
+    last_name: {
+      type: String,
+      required: true,
+    },
+    email: {
+      type: String,
+      required: true,
+    },
+    phone_no: {
+      type: String,
+      required: false,
+    },
+    password: {
+      type: String,
+      required: true,
+    },
+    image: {
+      type: String,
+      required: false,
+    },
+    token: {
+      type: String,
+      required: false,
+    },
+  },
+  { timestamps: true }
+);
+
+appendData = {
+  id: function () {
+    return this._id;
+  },
+  full_name: function () {
+    const firstName = this?.first_name ? this.first_name + " " : "";
+    const lastName = this?.last_name ? this.last_name : "";
+    return `${firstName}${lastName}`;
+  },
+};
+appendParams(User, appendData);
+
+module.exports = mongoose.model("User", User);

package/sample-schema.js

@@ -0,0 +1,49 @@
+const mongoose = require("mongoose");
+const Schema = mongoose.Schema;
+const { appendParams } = require("mongoose-backpack");
+
+const ${fileContent} = new Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+    },
+  },
+  { timestamps: true }
+);
+
+const appendData = {
+  id: function () {
+    return this._id;
+  },
+};
+appendParams(${fileContent}, appendData);
+
+const ${fileContent}Model = mongoose.model("${fileContent}", ${fileContent});
+
+// Created a change stream. The 'change' event gets emitted when there's a change in the database
+/*
+${fileContent}Model.watch().on("change", (data) => {
+  const timestamp = new Date();
+  const operationType = data.operationType;
+
+  switch (operationType) {
+    case "insert":
+      // TODO Logic Code...
+      console.log(timestamp, "Document created:", data.fullDocument);
+      break;
+    case "update":
+      // TODO Logic Code...
+      console.log(timestamp, "Document updated:", data.updateDescription);
+      break;
+    case "delete":
+      // TODO Logic Code...
+      console.log(timestamp, "Document deleted:", data.documentKey);
+      break;
+    default:
+      console.log(timestamp, "Unknown operation type:", operationType);
+  }
+});
+*/
+
+module.exports = ${fileContent}Model;

package/sample-validation.js

@@ -0,0 +1,4 @@
+const { body, param, check } = require("express-validator");
+const ${schemaName} = require("../../../models/${schemaName}");
+
+module.exports = defaultExport = [__validation__dynamic__code__];

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=nodejs-backpack for more information.