create-easy-stack 1.0.3

package/templates/node-express/files/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "1.0.0",
+  "main": "server.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "nodemon server.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.713.0",
+    "@aws-sdk/cloudfront-signer": "^3.709.0",
+    "@aws-sdk/s3-request-presigner": "^3.714.0",
+    "accesscontrol": "^2.2.1",
+    "amqplib": "^0.10.5",
+    "bcrypt": "^5.1.1",
+    "cloudinary": "^2.5.1",
+    "crypto": "^1.0.1",
+    "discord.js": "^14.16.3",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.1",
+    "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^2.2.4",
+    "lodash": "^4.17.21",
+    "mongoose": "^8.8.2",
+    "multer": "^1.4.5-lts.1",
+    "mysql2": "^3.11.5",
+    "nodemon": "^3.1.7",
+    "practice_v1.0": "file:",
+    "redis": "^4.7.0",
+    "slugify": "^1.6.6",
+    "uuid": "^11.0.3",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "compression": "^1.7.5",
+    "helmet": "^8.0.0",
+    "morgan": "^1.10.0"
+  }
+}

package/templates/node-express/files/server.js

@@ -0,0 +1,13 @@
+const app = require("./src/app");
+const PORT = process.env.PORT || 5000;
+
+const server = app.listen(PORT, () => {
+  console.log(`Backend starts with port ${PORT}`);
+});
+
+// SIGINT = Ctrl + C
+process.on("SIGINT", () => {
+  server.close(() => {
+    console.log("Exit Server Express");
+  });
+});

package/templates/node-express/files/src/app.js

@@ -0,0 +1,72 @@
+// 106k + 10k
+const express = require("express");
+const morgan = require("morgan");
+const helmet = require("helmet");
+const compression = require("compression");
+const { v4: uuidv4 } = require("uuid");
+const logger = require("./logger/mylogger.log.js");
+require("dotenv").config();
+
+const app = express();
+
+// init middleware
+app.use(morgan("dev"));
+app.use(helmet());
+app.use(compression());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// init logger - info of request
+app.use((req, res, next) => {
+  const requestId = req.headers["x-request-id"] || uuidv4();
+  req.requestId = requestId;
+  logger.info(`Input params :: ${req.method}`, [
+    req.path,
+    { requestId: req.requestId },
+    req.method === "POST" ? req.body : req.query,
+  ]);
+  next();
+});
+
+// init db
+require("./database/init.mongodb.level1.js");
+
+// test redis
+app.use("/redis", () => {
+  const productTest = require("./tests/product.test.js");
+  require("./tests/inventory.test.js");
+  setTimeout(() => {
+    productTest.purchaseProduct("product_id_01", 10);
+  }, 1000);
+});
+
+// init router
+app.use("/", require("./routes/index.route.js"));
+
+// handle error
+app.use((req, res, next) => {
+  const error = new Error("Not Found");
+  error.status = 404;
+  next(error);
+});
+
+app.use((error, req, res, next) => {
+  const statusCode = error.status || 500;
+  const resMessage = `${statusCode} - ${Date.now()} - Response - ${JSON.stringify(
+    error
+  )}`;
+  // logger of response
+  logger.error(`[${statusCode}] - ${error.message}`, [
+    req.path,
+    { requestId: req.requestId },
+    { message: resMessage },
+  ]);
+  return res.status(statusCode).json({
+    status: "error",
+    code: statusCode,
+    message: error.message || "Internal Server Error",
+  });
+});
+
+module.exports = app;
+// in this file, we have logger for request information and response of error

package/templates/node-express/files/src/auth/authUtils.js

@@ -0,0 +1,116 @@
+"use strict";
+
+const jwt = require("jsonwebtoken");
+const asyncHandler = require("../helpers/asyncHandler");
+const { AuthFailureError, NotFoundError } = require("../core/error.response");
+const { findByUserId } = require("../services/keyToken.service");
+
+const HEADERS = {
+  API_KEY: "x-api-key",
+  CLIENT_ID: "x-client-id",
+  AUTHORIZATION: "authorization",
+  REFRESH_TOKEN: "x-rtoken-id",
+};
+
+const createTokenPair = async (payload, privateKey, publicKey) => {
+  try {
+    const accessToken = await jwt.sign(payload, publicKey, {
+      expiresIn: "2 days",
+    });
+
+    const refreshToken = await jwt.sign(payload, privateKey, {
+      expiresIn: "7 days",
+    });
+
+    jwt.verify(accessToken, publicKey, (err, decode) => {
+      if (err) {
+        console.error("Verify error", err);
+      } else {
+        console.log("Decode verify:: ", decode);
+      }
+    });
+
+    return { accessToken, refreshToken };
+  } catch (error) {}
+};
+
+// authentication before logout
+const authentication = asyncHandler(async (req, res, next) => {
+  /**
+   * 1 - Check userId missing ?
+   * 2 - Get access token
+   * 3 - Verify token
+   * 4 - Check user in db
+   * 5 - Check keyStore with this userId
+   */
+  const userId = req.headers[HEADERS.CLIENT_ID];
+  if (!userId) {
+    throw new AuthFailureError("Invalid Request");
+  }
+  const keyStore = await findByUserId({ userId });
+
+  if (!keyStore) {
+    throw new NotFoundError("Not Found");
+  }
+  const accessToken = req.headers[HEADERS.AUTHORIZATION];
+  if (!accessToken) {
+    throw new AuthFailureError("Invalid Request");
+  }
+  try {
+    const decodeUser = jwt.verify(accessToken, keyStore.publicKey);
+    if (userId !== decodeUser.userId) {
+      throw new NotFoundError("Not Found");
+    }
+    req.keyStore = keyStore;
+    req.user = decodeUser;
+    console.log(">>> req.user: ", req.user);
+    return next();
+  } catch (error) {
+    throw new Error(error.message);
+  }
+});
+
+const authenticationV2 = asyncHandler(async (req, res, next) => {
+  /**
+   * 1 - Check userId missing ?
+   * 2 - Get access token
+   * 3 - Verify token
+   * 4 - Check user in db
+   * 5 - Check keyStore with this userId
+   */
+  const userId = req.headers[HEADERS.CLIENT_ID];
+  if (!userId) {
+    throw new AuthFailureError("Invalid Request");
+  }
+  const keyStore = await findByUserId({ userId });
+  if (!keyStore) {
+    throw new NotFoundError("Not Found");
+  }
+
+  const refreshToken = req.headers[HEADERS.REFRESH_TOKEN];
+  if (refreshToken) {
+    try {
+      const decodeUser = jwt.verify(refreshToken, keyStore.privateKey);
+      if (userId !== decodeUser.userId) {
+        throw new AuthFailureError("Invalid userId");
+      }
+      req.keyStore = keyStore;
+      req.user = decodeUser;
+      req.refreshToken = refreshToken;
+      return next();
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+});
+
+const verifyJWT = async (token, keySecret) => {
+  return await jwt.verify(token, keySecret);
+};
+
+module.exports = {
+  createTokenPair,
+  authentication,
+  verifyJWT,
+  authenticationV2,
+};

package/templates/node-express/files/src/auth/checkAuth.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const { findById } = require("../services/apiKey.service");
+
+const HEADERS = {
+  API_KEY: "x-api-key",
+  AUTHORIZATION: "authorization",
+};
+
+const checkApiKey = async (req, res, next) => {
+  try {
+    const key = req.headers[HEADERS.API_KEY]?.toString();
+    if (!key) {
+      return res.status(403).json({
+        message: "Forbidden",
+      });
+    }
+    // check objKey
+    const objKey = await findById(key);
+    if (!objKey) {
+      return res.status(403).json({
+        message: "Forbidden",
+      });
+    }
+    req.objKey = objKey;
+    return next();
+  } catch (error) {
+    return res.status(403).json({
+      message: "Forbidden",
+    });
+  }
+};
+
+const checkPermissions = (permission) => {
+  return (req, res, next) => {
+    if (!req.objKey.permissions) {
+      return res.status(403).json({
+        message: "Permissions denied",
+      });
+    }
+    const validPermission = req.objKey.permissions.includes(permission);
+    if (!validPermission) {
+      return res.status(403).json({
+        message: "Permissions denied",
+      });
+    }
+    return next();
+  };
+};
+
+const asyncHandler = (fn) => {
+  return (req, res, next) => {
+    fn(req, res, next).catch(next);
+  };
+};
+
+module.exports = {
+  checkApiKey,
+  checkPermissions,
+  asyncHandler
+};

package/templates/node-express/files/src/bucket_pattern/comment.model.js

@@ -0,0 +1,27 @@
+const { Schema, model } = require("mongoose");
+
+const bucketSchema = new Schema(
+  {
+    blogId: { type: String, defaul: "" },
+    count: { type: Number, required: true },
+    comments: {
+      type: Array,
+      default: [
+        {
+          commentId: { type: Number, required: true },
+          email: { type: String, default: "" },
+          body: { type: String, default: "" },
+          name: { type: String, default: "" },
+        },
+      ],
+    },
+  },
+  {
+    collection: "buckets",
+    timestamps: true,
+  }
+);
+
+module.exports = {
+  bucketModel: model("buckets", bucketSchema),
+};

package/templates/node-express/files/src/bucket_pattern/comment.service.js

@@ -0,0 +1,50 @@
+const { bucketModel } = require("./comment.model");
+
+const insertBucket = async ({ blogId, commentId, name, body, email }) => {
+  try {
+    const _blogId = new RegExp(`^${blogId}_`);
+    return await bucketModel.findOneAndUpdate(
+      {
+        blogId: _blogId,
+        count: { $lt: 10 },
+      },
+      {
+        $push: {
+          comments: {
+            email,
+            body,
+            name,
+            commentId,
+          },
+        },
+        $inc: { count: 1 },
+
+        $setOnInsert: {
+          blogId: `${blogId}_${new Date().getTime()}`,
+        },
+      },
+      {
+        new: true,
+        upsert: true,
+      }
+    );
+  } catch (error) {}
+};
+
+const listPaging = async ({ blogId, page, limit = 1 }) => {
+  try {
+    const _blogId = new RegExp(`^${blogId}_`);
+    return await bucketModel
+      .find({
+        blogId: _blogId,
+      })
+      .sort({ _id: 1 })
+      .skip((page - 1) * limit)
+      .limit(limit);
+  } catch (error) {}
+};
+
+module.exports = {
+  insertBucket,
+  listPaging,
+};

package/templates/node-express/files/src/config/config.aws-s3.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+  DeleteObjectCommand,
+} = require("@aws-sdk/client-s3");
+const dotenv = require("dotenv");
+
+dotenv.config();
+
+const S3Config = {
+  region: process.env.AWS_REGION,
+  credentials: {
+    accessKeyId: process.env.AWS_BUCKET_ACCESS_KEY,
+    secretAccessKey: process.env.AWS_BUCKET_SECRET_KEY,
+  },
+};
+
+const s3 = new S3Client(S3Config);
+
+module.exports = {
+  s3,
+  PutObjectCommand,
+  DeleteObjectCommand, 
+  GetObjectCommand,  // for downloading
+};

package/templates/node-express/files/src/config/config.cloudinary.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const cloudinary = require("cloudinary").v2;
+const dotenv = require("dotenv");
+dotenv.config();
+
+cloudinary.config({
+  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+  api_key: process.env.CLOUDINARY_API_KEY,
+  api_secret: process.env.CLOUDINARY_API_SECRET,
+});
+
+module.exports = cloudinary;

package/templates/node-express/files/src/config/config.mongodb.js

@@ -0,0 +1,25 @@
+const dev = {
+  app: {
+    port: process.env.DEV_APP_PORT,
+  },
+  db: {
+    host: process.env.DEV_DB_HOST,
+    port: process.env.DEV_DB_PORT,
+    name: process.env.DEV_DB_NAME,
+  },
+};
+
+const pro = {
+  app: {
+    port: process.env.PRO_APP_PORT,
+  },
+  db: {
+    host: process.env.PRO_DB_HOST,
+    port: process.env.PRO_DB_PORT,
+    name: process.env.PRO_DB_NAME,
+  },
+};
+
+const config = {dev, pro};
+const env = process.env.NODE_ENV || "dev";
+module.exports = config[env];

package/templates/node-express/files/src/config/config.multer.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const multer = require("multer");
+
+const uploadToMemory = multer({
+  storage: multer.memoryStorage(),
+  limits: { fileSize: 10 * 1024 * 1024 }, // 10MB
+});
+
+const uploadToDisk = multer({
+  storage: multer.diskStorage({
+    destination: (req, file, cb) => {
+      cb(null, "./src/temp/");
+    },
+    filename: (req, file, cb) => {
+      cb(null, Date.now() + "-" + file.originalname);
+    },
+  }),
+  limits: { fileSize: 10 * 1024 * 1024 }, // 10MB
+});
+
+module.exports = {
+  uploadToMemory,
+  uploadToDisk,
+};

package/templates/node-express/files/src/config/config.nodemailer.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const nodemailer = require("nodemailer");
+require("dotenv").config();
+
+const transporter = nodemailer.createTransport({
+  host: "smtp.gmail.com",
+  port: 587,
+  secure: true,
+  auth: {
+    user: process.env.AWS_EMAIL_APP_USER,
+    pass: process.env.AWS_EMAIL_APP_PASSWORD,
+  },
+});
+
+module.exports = transporter;

package/templates/node-express/files/src/controllers/access.controller.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const { CREATED, SuccessResponse } = require("../core/success.response");
+const AccessService = require("../services/access.service");
+
+class AccessController {
+  signUp = async (req, res, next) => {
+    new CREATED({
+      message: "Registered successfully",
+      metadata: await AccessService.signUp(req.body),
+    }).send(res);
+  };
+
+  login = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Logined successfully",
+      metadata: await AccessService.login(req.body),
+    }).send(res);
+  };
+
+  logout = async (req, res, next) => {
+    new SuccessResponse({
+      message: "Logout successfully",
+      metadata: await AccessService.logout(req.keyStore),
+    }).send(res);
+  };
+
+  refreshToken = async (req, res, next) => {
+    new SuccessResponse({
+      message: "RefreshToken successfully",
+      metadata: await AccessService.handleRefreshTokenV2({
+        refreshToken: req.refreshToken,
+        user: req.user,
+        keyStore: req.keyStore,
+      }),
+    }).send(res);
+  };
+}
+
+module.exports = new AccessController();
+
+/**
+ * {
+ *    statusCode
+ *    reasonPhrase
+ *    metadata
+ *    message
+ * }
+ */

package/templates/node-express/files/src/controllers/cart.controller.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const { SuccessResponse } = require("../core/success.response");
+const CartService = require("../services/cart.service");
+
+class CartController {
+  async addToCart(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CartService.addProductToCart(req.body),
+    }).send(res);
+  }
+
+  async updateCart(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CartService.updateCart(req.body),
+    }).send(res);
+  }
+
+  async getListProductsFromCart(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CartService.getListProductsFromCart({
+        userId: req.params.id,
+      }),
+    }).send(res);
+  }
+
+  async removeItemFromCart(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CartService.removeItemFromCart(req.body),
+    }).send(res);
+  }
+}
+
+module.exports = new CartController();

package/templates/node-express/files/src/controllers/checkout.controller.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const { SuccessResponse } = require("../core/success.response");
+const CheckoutService = require("../services/checkout.service");
+
+class CheckoutController {
+  async checkoutReview(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CheckoutService.checkoutReview(req.body),
+    }).send(res);
+  }
+}
+
+module.exports = new CheckoutController();

package/templates/node-express/files/src/controllers/comment.controller.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const { SuccessResponse } = require("../core/success.response");
+const CommentService = require("../services/comment.service");
+
+class CommentController {
+  async createComment(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CommentService.createComment(req.body),
+    }).send(res);
+  }
+
+  async getCommentsByParentId(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CommentService.getCommentsByParentId(req.body),
+    }).send(res);
+  }
+
+  async deleteComments(req, res, next) {
+    new SuccessResponse({
+      message: "Success",
+      metadata: await CommentService.deleteComment(req.body),
+    }).send(res);
+  }
+}
+
+module.exports = new CommentController();