create-easy-stack 1.0.3

package/templates/node-express/files/src/database/init.redis.js

@@ -0,0 +1,119 @@
+"use strict";
+
+const redis = require("redis");
+const { RedisConnectionError } = require("../core/error.response");
+// redisClient is used to connect to the redis server
+// redis server is used to store the data in key-value pairs
+// redis server is located in the same machine as the application
+/** level 1: connect to redis server */
+// const redisClient = redis.createClient({
+//   host: process.env.REDIS_HOST,
+//   port: process.env.REDIS_PORT,
+//   password: process.env.REDIS_PASSWORD,
+//   username: process.env.REDIS_USERNAME,
+// });
+
+// redisClient.ping((err, res) => {
+//   if (err) {
+//     console.log("err:::error connecting to redis", err);
+//   } else {
+//     console.log("res:::connected to redis", res);
+//   }
+// });
+
+// redisClient.on("error", (err) => {
+//   console.log("err:::error connecting to redis", err);
+// });
+
+// module.exports = redisClient;
+
+/** level 2: connect to redis server using redis-cli */
+// a connection is a client - an instance to a pool of connections
+// we can have multiple connections to the same redis server (pool of connections)
+let client = {};
+const REDIS_CONNECT_TIMEOUT = 10000;
+const REDIS_CONNECT_MESSAGE = {
+  code: -99,
+  message: {
+    vn: "Redis bị lỗi rồi",
+    en: "Redis is error",
+  },
+};
+let statusConnectRedis = {
+  CONNECT: "connect",
+  END: "end",
+  RECONNECT: "reconnect",
+  DISCONNECT: "disconnect",
+  ERROR: "error",
+};
+let connectionTimeoutNumber;
+
+const handleEventConnectRedis = ({ connectionRedis }) => {
+  if (!connectionRedis) return;
+  connectionRedis.on(statusConnectRedis.CONNECT, () => {
+    console.log("res:::connected to redis");
+  });
+  connectionRedis.on(statusConnectRedis.END, () => {
+    console.log("res:::end connection to redis");
+    handleTimeoutConnectRedis(connectionRedis);
+  });
+  connectionRedis.on(statusConnectRedis.RECONNECT, () => {
+    console.log("res:::reconnect to redis");
+    clearTimeout(connectionTimeoutNumber);
+  });
+  connectionRedis.on(statusConnectRedis.DISCONNECT, () => {
+    console.log("res:::disconnect to redis");
+  });
+  connectionRedis.on(statusConnectRedis.ERROR, (err) => {
+    console.log("res:::error connecting to redis", err);
+    // retry connect to redis
+    handleTimeoutConnectRedis(connectionRedis);
+  });
+};
+
+const handleTimeoutConnectRedis = (connectionRedis) => {
+  if (!connectionRedis) return;
+  connectionTimeoutNumber = connectionRedis.setTimeout(
+    REDIS_CONNECT_TIMEOUT,
+    () => {
+      throw new RedisConnectionError({
+        message: REDIS_CONNECT_MESSAGE.message.vn,
+        statusCode: REDIS_CONNECT_MESSAGE.code,
+      });
+    }
+  );
+};
+
+const initRedis = () => {
+  const instanceRedis = redis.createClient();
+  client.instanceConnect = instanceRedis;
+  handleEventConnectRedis(instanceRedis);
+  handleTimeoutConnectRedis(instanceRedis);
+};
+
+const getRedis = () => client;
+
+const closeRedis = () => {
+  if (!client.instanceConnect) return;
+  client.instanceConnect.quit();
+  client.instanceConnect = null;
+};
+
+module.exports = {
+  initRedis,
+  getRedis,
+  closeRedis,
+};
+
+/**
+    To connect to redis server, we need to supply the following information:
+    - host: the host of the redis server
+    - port: the port of the redis server
+    - password: the password of the redis server
+    - username: the username of the redis server
+    because redis server is a database like mysql, postgresql, etc.
+    we need to supply the host, port, password, username to connect to the redis server
+    redis server could be local or remote
+    if redis server is local, we can use the default host and port
+    if redis server is remote, we need to supply the host, port, password, username
+*/

package/templates/node-express/files/src/helpers/asyncHandler.js

@@ -0,0 +1,7 @@
+const asyncHandler = (fn) => {
+  return (req, res, next) => {
+    fn(req, res, next).catch(next);
+  };
+};
+
+module.exports = asyncHandler;

package/templates/node-express/files/src/helpers/check.connect.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const mongoose = require("mongoose");
+const os = require("os");
+const process = require("process");
+const _SECONDS = 5000;
+
+// count connection
+const countConnect = () => {
+  const numConnection = mongoose.connections.length;
+  console.log(`Number of connections:::${numConnection}`);
+};
+
+// check overload
+const checkOverload = () => {
+  setInterval(() => {
+    const numConnection = mongoose.connections.length;
+    const numCores = os.cpus().length;
+    const memoryUsage = process.memoryUsage().rss;
+    // Example maximum number of connections per core is 5
+    console.log(`Memory usage::${memoryUsage / 1024 / 1024} MB`);
+    console.log(`Active connections::::${numConnection}`);
+    const maxConnections = numCores * 5;
+    if (numConnection > maxConnections) {
+      console.log("Connections overload detected");
+    }
+  }, _SECONDS);
+};
+module.exports = { countConnect, checkOverload };

package/templates/node-express/files/src/keys/private_key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC8Zd3WVhm7vKLD
+xbeWZc9kSVhYnOlLMP/1NEU1hL06pNdaf64126WIpA9/Z1DrgLkM1ktWxPKt62/c
+iAWsijwBmZ3+0QNTDsg/siFGDkt9saJNS8S+ybrGD9f/DOsdm1HfHKmLQaL0U6nW
+Rw4QtU7XgYSvb2TUA44p4Pi6tpFNzdA+2XR6uvWWzCsvBlzzQZ/jo93hOTiGb7YC
+3ASdElDyXs19R+0n3m/PJdla9iXEIfY7sbMdJdPIid9hao9rglB2lsseik/hXHVa
+5gZBgJrfU+07ccW7KlzSVBhopBY0NzXeIH5wEMMbgszmh4ZqffIVI69ZB7rMuv7o
+Lr4OosebAgMBAAECggEAV1L8LUIBcYRxCT9W5i5Qn9JjUceBVyniKhzNS444S7tm
+Wns+G5awtpIc4NfZqR8kJvAZQaHOPpEXa2fdAWmdgLxcgGUPHmuGpAeD5r3vfdZd
+PWi2TByjJvTnEEBDpph8rWbSq0qEJq201i5fNZ1kav2Mq+h9Gsx/E6hEgf7ngODu
+HHS76xIYLHy7o+cxsLkGOTXt1YYueF9nOAkhKGAIifcLcX+CW76fTNcIQPLjPoHk
+Pmst/NGgWCPw3AJTFSaD37vplRS149PUyZpkwPxzLbk+yA8ft8LUp+e5HhplfBvo
+VDrBjSBtaR9R6p5Gk5IRdWxofuVGg2BT0tTRuQTmaQKBgQDnaoa9i2qaTey+gRAm
+Ws6b7RotUY9eK4G0pIAEKWGTBeC6EgLODb5QbJy0nTbu2IQhoUx4z8+JOyI53jAg
+1VHnOMF+EnadRaQdZACXzKJdoOJ0meu91F1pOhlVY5fEZngBim92AiCMio904iVr
+UVXFfr3VnhJlzRmaPQAaTzaSdwKBgQDQaXB3+8t4iAdYHHr/zzrfVeBF0Mg3jtGG
+KhByv7ZuXm9Q5H2T+twhNbLxWdSEd1vnoS8yMeaPGmBh0MR49PNUMjatX2v3gaO5
+lYhY9p+fPrnovQxf176c67eFcSR1jHB/OGceKAZJ2hpYeyy1QQwElA5f3fwSDdLV
+1LLeqCY4/QKBgQDYxOtT7506zxWdWW4UT2lLm+yyWLzP/DbyTEjyHQUeYBoika54
+71y/Hw4nDUEguEYE7n+ghyCjLnYf+KXii4+95GczPf5H0a0qLrtzdib9Ry/5AxlU
+5vFdGSQT3UeTnFx7LP69br6ohz5bwV5FyZlrdw5BZGFdZKK/3LYU7vByfwKBgGuy
+MMYvvYM5d+IWRZEvOxLxw4UQUIY1LRyRXBKP8uuxrQA2MpZniZ03rJJ/gww4yas2
+Zbcghi3oyWmCgiSnH56gnBSXPKmXuk1KcjzWpMGbnmIgXuagDAX24Mz6HIcJ3ZBA
+SzkQIb/EDt0uOXoodNdg0tTDV2DU9+A7m3rnlWjZAoGAE3ijGsdogIkgKrOics/K
+t8v7+ug3yo3opK77yNc60nOXicE2SqyQhhTYUOcL/YYs6ptrm1ExQaJ2ErLUBUVE
+akOkM0fKtxvMHBjU3dyjhMz94DfDcNeB4lH5ehV8gIriYwmXGGrneQQ61yAtj+j+
+/mfWkBNrR8DHZiry8c/ZibE=
+-----END PRIVATE KEY-----

package/templates/node-express/files/src/keys/public_key.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvGXd1lYZu7yiw8W3lmXP
+ZElYWJzpSzD/9TRFNYS9OqTXWn+uNduliKQPf2dQ64C5DNZLVsTyretv3IgFrIo8
+AZmd/tEDUw7IP7IhRg5LfbGiTUvEvsm6xg/X/wzrHZtR3xypi0Gi9FOp1kcOELVO
+14GEr29k1AOOKeD4uraRTc3QPtl0err1lswrLwZc80Gf46Pd4Tk4hm+2AtwEnRJQ
+8l7NfUftJ95vzyXZWvYlxCH2O7GzHSXTyInfYWqPa4JQdpbLHopP4Vx1WuYGQYCa
+31PtO3HFuypc0lQYaKQWNDc13iB+cBDDG4LM5oeGan3yFSOvWQe6zLr+6C6+DqLH
+mwIDAQAB
+-----END PUBLIC KEY-----

package/templates/node-express/files/src/logger/discord.log.js

@@ -0,0 +1,26 @@
+// 1314221126024560650
+"use strict";
+
+const { Client, GatewayIntentBits } = require("discord.js");
+const client = new Client({
+  intents: [
+    GatewayIntentBits.DirectMessages,
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+  ],
+});
+
+client.on("ready", () => {
+  console.log(`Logged is as ${client.user.tag}`);
+});
+
+// const token = process.env.TOKEN_DISCORD;
+client.login(token);
+
+client.on("messageCreate", (msg) => {
+  if (msg.author.bot) return;
+  if (msg.content.toLowerCase() === "hello") {
+    msg.reply("Hello, How can I help you!");
+  }
+});

package/templates/node-express/files/src/logger/discord.log.v2.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const { Client, GatewayIntentBits } = require("discord.js");
+require("dotenv").config();
+const { CHANNEL_ID, TOKEN_DISCORD } = process.env;
+
+class LoggerService {
+  constructor() {
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+    });
+    // add channelId
+    this.channelId = CHANNEL_ID;
+    this.client.on("ready", () => {
+      console.log(`Logged is as ${this.client.user.tag}`);
+    });
+    this.client.login(TOKEN_DISCORD);
+  }
+
+  sendToMessage(message = "message") {
+    const channel = this.client.channels.cache.get(this.channelId);
+    if (!channel) {
+      console.error(`Could not find the channel...`, this.channelId);
+      return;
+    }
+    channel.send(message).catch((e) => console.error(e));
+  }
+
+  sendToFormatCode(logData) {
+    const {
+      code,
+      message = "This is some additional information about the code",
+      title = "Code Example",
+    } = logData;
+    const codeMessage = {
+      content: message,
+      embeds: [
+        {
+          color: parseInt("00ff00", 16),
+          title,
+          description: "```json\n" + JSON.stringify(code, null, 2) + "\n ```",
+        },
+      ],
+    };
+    this.sendToMessage(codeMessage);
+  }
+}
+
+// const loggerService = new LoggerService();
+module.exports = new LoggerService();
+// Discord password: Thinh09122003

package/templates/node-express/files/src/logger/mylogger.log.js

@@ -0,0 +1,130 @@
+const winston = require("winston");
+require("winston-daily-rotate-file");
+const { v4: uuidv4 } = require("uuid");
+// level: error, warn, info, verbose, debug
+
+class MyLogger {
+  constructor() {
+    const formatPrint = winston.format.printf(
+      ({ level, message, timestamp, context, requestId, metadata }) => {
+        return `[${timestamp}] - [${level}] - [${context}] - [${requestId}] - [${JSON.stringify(
+          metadata
+        )}] - ${message}`;
+      }
+    );
+
+    this.logger = winston.createLogger({
+      level: "info",
+      format: winston.format.combine(
+        winston.format.timestamp({
+          format: "YYYY-MM-DD HH:mm:ss",
+        }),
+        formatPrint
+      ),
+      transports: [
+        new winston.transports.Console(),
+        new winston.transports.DailyRotateFile({
+          filename: "logs/application-%DATE%.info.log",
+          dirname: "./src/logs",
+          datePattern: "YYYY-MM-DD",
+          zippedArchive: true, // true: compress the file after maxSize before deleting (backup)
+          maxSize: "20m", // 20mb => create new file if over 20mb
+          maxFiles: "14d", // all logs in the last 14 days will be compressed and deleted
+          format: winston.format.combine(
+            winston.format.timestamp({
+              format: "YYYY-MM-DD HH:mm:ss",
+            }),
+            formatPrint
+          ),
+          level: "info",
+        }),
+        new winston.transports.DailyRotateFile({
+          filename: "logs/application-%DATE%.error.log",
+          dirname: "./src/logs",
+          datePattern: "YYYY-MM-DD",
+          zippedArchive: true, // true: compress the file after maxSize before deleting (backup)
+          maxSize: "20m", // 20mb => create new file if over 20mb
+          maxFiles: "14d", // all logs in the last 14 days will be compressed and deleted
+          format: winston.format.combine(
+            winston.format.timestamp({
+              format: "YYYY-MM-DD HH:mm:ss",
+            }),
+            formatPrint
+          ),
+          level: "error",
+        }),
+      ],
+    });
+  }
+
+  commonParams(params) {
+    let context, req, metadata;
+    if (!Array.isArray(params)) {
+      context = params.context;
+      req = params.req;
+      metadata = params.metadata;
+    } else {
+      [context, req, metadata] = params;
+    }
+    const requestId = req?.id || req?.headers["x-request-id"] || uuidv4();
+    return { context, requestId, metadata };
+  }
+  // log, error, debug, warn override this.logger => by level
+  log(message, params) {
+    const paramsLog = this.commonParams(params);
+    const logObject = Object.assign(
+      {
+        message,
+      },
+      paramsLog
+    );
+
+    this.logger.info(logObject);
+  }
+
+  error(message, params) {
+    const paramsLog = this.commonParams(params);
+    const logObject = Object.assign(
+      {
+        message,
+      },
+      paramsLog
+    );
+    this.logger.error(logObject);
+  }
+
+  debug(message, params) {
+    const paramsLog = this.commonParams(params);
+    const logObject = Object.assign(
+      {
+        message,
+      },
+      paramsLog
+    );
+    this.logger.debug(logObject);
+  }
+
+  warn(message, params) {
+    const paramsLog = this.commonParams(params);
+    const logObject = Object.assign(
+      {
+        message,
+      },
+      paramsLog
+    );
+    this.logger.warn(logObject);
+  }
+}
+
+module.exports = new MyLogger();
+// traceID: x-request-id
+/*
+  1. Level => info, error, debug, warn
+    1.1 error: serious problems => hot fix
+    1.2 warn: potential problems => fix later (not urgent)
+    1.3 info: normal but important information for improving performance
+    1.4 debug: detailed information for developers
+  2. Context
+  3. RequestId => x-request-id
+  4. Metadata => result (response)
+*/

package/templates/node-express/files/src/logger/winston.log.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const winston = require("winston");
+const { combine, timestamp, printf, json, align } = winston.format;
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || "debug",
+  format: combine(
+    timestamp({
+      format: "YYYY-MM-DD HH:mm:ss.SSS A",
+    }),
+    align(),
+    printf((info) => {
+      return `${info.timestamp} - ${info.level}: ${info.message}`;
+    })
+    // printf is a callback function that formats the custom log message
+  ),
+  transports: [
+    new winston.transports.Console(),
+    new winston.transports.File({
+      dirname: "./src/logs",
+      filename: "test.log",
+    }),
+  ],
+});
+
+module.exports = logger;

package/templates/node-express/files/src/middlewares/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const Logger = require("../logger/discord.log.v2");
+
+const pushToLogDiscord = async (req, res, next) => {
+  try {
+    console.log(req.get("host"));
+    Logger.sendToFormatCode({
+      title: `Method: ${req.method}`,
+      code: req.method === "GET" ? req.query | req.params : req.body,
+      message: `${req.get("host")} ${req.originalUrl}`,
+    });
+    return next();
+  } catch (error) {
+    next(error);
+  }
+};
+
+module.exports = {
+  pushToLogDiscord,
+};

package/templates/node-express/files/src/middlewares/rbac.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import { roleList } from "../services/rbac.service";
+
+const { AuthFailureError } = require("../core/error.response");
+const rbac = require("./role.middleware");
+/**
+ *
+ * @param {string} action // read, delete, update, create
+ * @param {*} resource  // profile, balance
+ * @returns
+ */
+
+export const grantAccess = (action, resource) => {
+  return async (req, res, next) => {
+    try {
+      rbac.setGrants(
+        await roleList({
+          userId: req.user.userId,
+        })
+      );
+      const role_name = req.query.role;
+      const permission = await rbac.can(role_name)[action](resource);
+      if (!permission.granted) {
+        throw new AuthFailureError("You are not allowed to do this action");
+      }
+      next();
+    } catch (error) {
+      next(error);
+    }
+  };
+};
+
+
+// FLow of rbac
+// what is any, own...
+// $unwind, $project, $lookup in mongoose

package/templates/node-express/files/src/middlewares/role.middleware.js

@@ -0,0 +1,12 @@
+const AccessControl = require("accesscontrol");
+// grant list fetched from DB (to be converted to a valid grants object, internally)
+// let grantList = [
+//   {
+//     role: "admin",
+//     resource: "profile",
+//     action: "readAny",
+//     attributes: "*, !views",
+//   },
+//   { role: "shop", resource: "profile", action: "readOwn", attributes: "*" },
+// ];
+module.exports = new AccessControl();

package/templates/node-express/files/src/models/KeyToken.model.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const { default: mongoose, Types, model } = require("mongoose");
+const COLLECTION_NAME = "KeyTokens";
+const DOCUMENT_NAME = "KeyToken";
+
+const keyTokenSchema = new mongoose.Schema(
+  {
+    user: {
+      type: Types.ObjectId,
+      ref: "User",
+      required: true,
+    },
+    publicKey: {
+      type: String,
+      required: true,
+    },
+    privateKey: {
+      type: String,
+      required: true,
+    },
+    refreshToken: {
+      type: String,
+      required: true,
+    },
+    refreshTokenUsed: {
+      type: Array,
+      default: [],
+    },
+  },
+  {
+    timestamps: true,
+    collection: COLLECTION_NAME,
+  }
+);
+
+module.exports = model(DOCUMENT_NAME, keyTokenSchema);

package/templates/node-express/files/src/models/apiKey.model.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const { default: mongoose, model } = require("mongoose");
+
+const DOCUMENT_NAME = "ApiKey";
+const COLLECTION_NAME = "ApiKeys";
+
+const apiKeySchema = new mongoose.Schema(
+  {
+    key: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    status: {
+      type: Boolean,
+      default: true,
+    },
+    permissions: {
+      type: [String],
+      required: true,
+      enum: ["0000", "1111", "2222"],
+    },
+  },
+  {
+    timestamps: true,
+    collection: COLLECTION_NAME,
+  }
+);
+
+module.exports = model(DOCUMENT_NAME, apiKeySchema);

package/templates/node-express/files/src/models/cart.model.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const { default: mongoose, Schema, model, Types } = require("mongoose");
+const COLLECTION_NAME = "Carts";
+const DOCUMENT_NAME = "Cart";
+
+const cartSchema = new mongoose.Schema(
+  {
+    cart_products: {
+      type: Array,
+      required: true,
+      default: [],
+      /*
+        [
+            {
+                product_id,
+                shop_id,
+                quantity,
+                price,
+                name
+            }
+        ]
+     */
+    },
+    cart_state: {
+      type: String,
+      required: true,
+      enum: ["ACTIVE", "COMPLETED", "FAILED", "PENDING"],
+      default: "ACTIVE",
+    },
+    cart_count_product: {
+      type: Number,
+      default: 0,
+    },
+    // cart cua user nao
+    cart_user_id: {
+      type: Types.ObjectId,
+      required: true,
+    },
+  },
+  {
+    timestamps: true,
+    collection: COLLECTION_NAME,
+  }
+);
+
+module.exports = model(DOCUMENT_NAME, cartSchema);

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

@@ -0,0 +1,43 @@
+"use strict";
+
+const { default: mongoose, Schema, model, Types } = require("mongoose");
+const COLLECTION_NAME = "Comments";
+const DOCUMENT_NAME = "Comment";
+
+const cartSchema = new mongoose.Schema(
+  {
+    comment_productId: {
+      type: Types.ObjectId,
+      ref: "Product",
+    },
+    comment_userId: {
+      type: Types.ObjectId,
+    },
+    comment_content: {
+      type: String,
+      default: "comment text",
+    },
+    comment_left: {
+      type: Number,
+      default: 0,
+    },
+    comment_right: {
+      type: Number,
+      default: 0,
+    },
+    comment_parentId: {
+      type: Types.ObjectId,
+      ref: DOCUMENT_NAME,
+    },
+    isDeleted: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  {
+    timestamps: true,
+    collection: COLLECTION_NAME,
+  }
+);
+
+module.exports = model(DOCUMENT_NAME, cartSchema);