create-easy-stack 1.0.3

package/templates/node-express/files/src/services/redisPubSub.service.js

@@ -0,0 +1,72 @@
+const redis = require("redis");
+
+class RedisPubSubService {
+  constructor() {
+    this.subscriber = redis.createClient();
+    this.publisher = redis.createClient();
+  }
+
+  async connectClients() {
+    try {
+      if (!this.publisher.isOpen) {
+        console.log(">>> connect publisher");
+        await this.publisher.connect();
+      }
+      if (!this.subscriber.isOpen) {
+        console.log(">>> connect subscriber");
+        await this.subscriber.connect();
+      }
+    } catch (error) {
+      console.log("Error connecting to Redis:", error);
+      throw error;
+    }
+  }
+
+  async publish(channel, message) {
+    await this.connectClients(); // Ensure the clients are connected
+    return new Promise((resolve, reject) => {
+      this.publisher.publish(channel, message, (err, reply) => {
+        if (err) {
+          console.log("Error in publish:", err);
+          reject(err);
+        } else {
+          resolve(reply);
+        }
+      });
+    });
+  }
+
+  async subscribe(channel, callback) {
+    await this.connectClients(); // Ensure the clients are connected
+    console.log(`Subscribing to channel: ${channel}`);
+
+    try {
+      // Subscribe to the channel
+      await this.subscriber.subscribe(channel, (message) => {
+        console.log(`Message received on channel ${channel}: ${message}`);
+        if (typeof callback === "function") {
+          callback(channel, message);
+        } else {
+          console.error("Provided callback is not a function.");
+        }
+      });
+
+      console.log(`Successfully subscribed to channel: ${channel}`);
+    } catch (err) {
+      console.error("Error subscribing to channel:", err);
+    }
+  }
+
+  // Add a method for cleanup/disconnection if needed
+  async disconnect() {
+    try {
+      await this.publisher.quit();
+      await this.subscriber.quit();
+      console.log("Redis clients disconnected.");
+    } catch (error) {
+      console.log("Error disconnecting Redis clients:", error);
+    }
+  }
+}
+
+module.exports = new RedisPubSubService();

package/templates/node-express/files/src/services/shop.service.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const shopModel = require("../models/shop.model");
+
+const findByEmail = async ({
+  email,
+  select = {
+    email: 1,
+    password: 1,
+    name: 1,
+    status: 1,
+    roles: 1,
+  },
+}) => {
+  console.log(">>> email: ", email);
+  return await shopModel.findOne({ email: email }).select(select).lean();
+};
+
+module.exports = {
+  findByEmail,
+};

package/templates/node-express/files/src/services/sku.service.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { SKU } = require("../models/sku.model");
+const { randomSpuId } = require("../utils");
+
+class SKUService {
+  static createNewSku = async ({ spu_id, sku_list }) => {
+    try {
+      const convertSkuList = sku_list.map((sku) => ({
+        ...sku,
+        spu_id,
+        sku_id: `${spu_id}_${randomSpuId()}`,
+      }));
+
+      const newSkuList = await SKU.insertMany(convertSkuList);
+
+      return newSkuList;
+    } catch (error) {
+      throw new Error(error);
+    }
+  };
+
+  static getDetailSku = async ({ sku_id, spu_id }) => {
+    try {
+      // read cache
+      // cache miss
+      const foundSku = await SKU.findOne({ sku_id, spu_id }).lean().exec();
+      if (foundSku) {
+        // set cache here
+      }
+      return foundSku;
+    } catch (error) {
+      throw new Error(error);
+    }
+  };
+
+  static getListSkuBySpuId = async ({ spu_id }) => {
+    try {
+      // read cache
+      // cache miss
+      const foundSkuList = await SKU.find({ spu_id }).lean().exec();
+      if (foundSkuList) {
+        // set cache here
+      }
+      return foundSkuList;
+    } catch (error) {
+      throw new Error(error);
+    }
+  };
+}
+
+module.exports = SKUService;

package/templates/node-express/files/src/services/spu.service.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const { SPU } = require("../models/spu.model");
+const {
+  NotFoundError,
+  ConflictRequestError,
+} = require("../core/error.response");
+const { findShopById } = require("../models/repository/shop.repo");
+const { findSpuById } = require("../models/repository/spu.repo");
+const { randomSpuId } = require("../utils");
+const SKUService = require("./sku.service");
+const _ = require("lodash");
+class SPUService {
+  static createNewSpu = async ({
+    spu_name,
+    spu_slug,
+    spu_description,
+    spu_images,
+    spu_category,
+    spu_price,
+    spu_shop,
+    spu_attributes,
+    spu_ratingsAverage,
+    spu_variations,
+    spu_quantity,
+    sku_list = [],
+  }) => {
+    try {
+      // check if shop exists
+      const foundShop = await findShopById({ shop_id: spu_shop });
+      if (!foundShop) {
+        throw NotFoundError("Shop not found");
+      }
+      // check if spu_id is already exists
+      const foundSpu = await findSpuById({ spu_id });
+      if (foundSpu) {
+        throw ConflictRequestError("Spu already exists");
+      }
+
+      // create new spu
+      const newSpu = await SPU.create({
+        spu_id: randomSpuId(),
+        spu_name,
+        spu_slug,
+        spu_description,
+        spu_images,
+        spu_category,
+        spu_price,
+        spu_shop,
+        spu_attributes,
+        spu_ratingsAverage,
+        spu_variations,
+        spu_quantity,
+      });
+
+      // if sku_list is not empty, create skus list
+      if (newSpu && sku_list.length > 0) {
+        // 3. create skus list
+        await SKUService.createNewSku({
+          spu_id: newSpu.spu_id,
+          sku_list,
+        });
+      }
+
+      // 4. sync data via elasticsearch (search service)
+
+      // return newSpu
+      return newSpu;
+    } catch (error) {
+      throw new Error(error);
+    }
+  };
+
+  static getDetailSpu = async ({ spu_id }) => {
+    const foundSpu = await findSpuById({ spu_id, isPublished: true });
+    if (!foundSpu) {
+      throw NotFoundError("Spu not found");
+    }
+    const foundSkuList = await SKUService.getListSkuBySpuId({ spu_id });
+    return {
+      spu_info: _.omit(foundSpu, ["__v", "updatedAt"]),
+      sku_list: foundSkuList.map((sku) =>
+        _.omit(sku, ["__v", "updatedAt", "createdAt", "isDeleted"])
+      ),
+    };
+  };
+}
+
+module.exports = SPUService;

package/templates/node-express/files/src/services/template.service.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const { NotFoundError } = require("../core/error.response");
+const { Template } = require("../models/template.model");
+const { generateTemplateHtml } = require("../utils/template.html");
+
+class TemplateService {
+  static async getTemplate({ template_name = null }) {
+    // check if template_id exists
+    const template = await Template.findOne({ template_name }).lean().exec();
+    if (!template) {
+      throw new NotFoundError("Template not found");
+    }
+    return template;
+  }
+
+  static async createTemplate({
+    template_id = null,
+    template_name = null,
+    template_html = null,
+  }) {
+    // check if template_id exists
+    const template = await Template.findOne({ template_name }).lean().exec();
+    if (template) {
+      throw new BadRequestError("Template already exists");
+    }
+
+    const templateHtml = template_html || generateTemplateHtml();
+
+    // create template
+    const newTemplate = await Template.create({
+      template_id,
+      template_name,
+      template_html: templateHtml,
+    });
+
+    return newTemplate;
+  }
+}
+
+module.exports = TemplateService;

package/templates/node-express/files/src/services/upload.s3.service.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const {
+  s3,
+  PutObjectCommand,
+  GetObjectCommand,
+} = require("../config/config.aws-s3");
+const { BadRequestError } = require("../core/error.response");
+// const { getSignedUrl } = require("@aws-sdk/s3-request-presigner");
+const { getSignedUrl } = require("@aws-sdk/cloudfront-signer");
+const cloudfrontDomain = process.env.AWS_CLOUDFRONT_DOMAIN;
+
+class UploadAwsService {
+  static async uploadImageFromLocalS3({ file }) {
+    try {
+      if (!file) {
+        throw new BadRequestError("No file provided");
+      }
+      const imageName = `${Date.now()}-${file.originalname}`;
+      // put to s3 first
+      const commandForPut = new PutObjectCommand({
+        Bucket: process.env.AWS_BUCKET_NAME,
+        Key: imageName,
+        Body: file.buffer,
+        ContentType: "image/jpeg",
+      });
+      const result = await s3.send(commandForPut);
+
+      // s3
+      // using getSignedUrl to publish the url to the community
+      // const commandForRead = new GetObjectCommand({
+      //   Bucket: process.env.AWS_BUCKET_NAME,
+      //   Key: imageName,
+      // });
+
+      // cloudfront signer
+      const signedUrl = await getSignedUrl({
+        url: `${cloudfrontDomain}/${imageName}`,
+        dateLessThan: new Date(Date.now() + 1000 * 60),
+        keyPairId: process.env.AWS_CLOUDFRONT_PUBLIC_KEY_ID,
+        privateKey: process.env.AWS_CLOUDFRONT_PRIVATE_KEY,
+      });
+
+      return {
+        url: signedUrl,
+        result,
+      };
+    } catch (error) {
+      console.error(error);
+      throw new BadRequestError(error.message);
+    }
+  }
+}
+
+module.exports = UploadAwsService;

package/templates/node-express/files/src/services/upload.service.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const cloudinary = require("../config/config.cloudinary");
+
+class UploadService {
+  static async uploadImageFromUrl({ url }) {
+    try {
+      // Implement logic to upload image from URL
+      const urlImage = url;
+      // Return the uploaded file's path
+      const folderName = "products/upload";
+      const fileName = "product_image.jpg";
+      const result = await cloudinary.uploader.upload(urlImage, {
+        folder: folderName,
+        public_id: fileName,
+        use_filename: true,
+        overwrite: true,
+      });
+      return {
+        url: result.secure_url,
+      };
+    } catch (error) {
+      console.error(error);
+      throw new BadRequestError(error.message);
+    }
+  }
+
+  static async uploadImageFromLocal({ path, folderName = "products/upload" }) {
+    try {
+      // Return the uploaded file's path
+      console.log("running upload");
+      const fileName = "product_image";
+      const result = await cloudinary.uploader.upload(path, {
+        folder: folderName,
+        public_id: fileName,
+        use_filename: true,
+        overwrite: true,
+      });
+      return {
+        url: result.secure_url,
+      };
+    } catch (error) {
+      console.error(error);
+      throw new BadRequestError(error.message);
+    }
+  }
+
+  static async uploadImagesFromLocal({
+    files,
+    folderName = "products/upload",
+  }) {
+    try {
+      // Return the uploaded file's path
+      if (!files.length) return;
+      const uploaded_urls = [];
+      for (const file of files) {
+        const result = await cloudinary.uploader.upload(file.path, {
+          folder: folderName,
+          use_filename: true,
+          overwrite: true,
+        });
+        uploaded_urls.push(result.secure_url);
+      }
+      return {
+        uploaded_urls,
+      };
+    } catch (error) {
+      console.error(error);
+      throw new BadRequestError(error.message);
+    }
+  }
+}
+
+module.exports = UploadService;

package/templates/node-express/files/src/services/user.service.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const { BadRequestError } = require("../core/error.response");
+const { OtpService } = require("../services/otp.service");
+const { User } = require("../models/user.model");
+const bcrypt = require("bcrypt");
+const crypto = require("crypto");
+const { createTokenPair } = require("../utils/jwt");
+const { getInfoData } = require("../utils/data");
+const { createUser } = require("../models/repository/user.repo");
+const Role = require("../models/role.model");
+
+class UserService {
+  static async findUserByEmail({ email = null }) {
+    const user = await User.findOne({ email }).lean().exec();
+    return user;
+  }
+
+  static async checkRegisterEmailToken({ email = null, token = null }) {
+    const otp = await OtpService.checkOtp({ email, token });
+    if (!otp) {
+      throw new BadRequestError("Invalid token");
+    }
+    const { otp_email: email } = otp;
+    const user = await UserService.findUserByEmail({ email });
+    if (user) {
+      throw new BadRequestError("Email already registered");
+    }
+
+    const hassPassword = await bcrypt.hash(email, 10);
+    const role = await Role.findOne({ role_name: "user" });
+    const newUser = await createUser({
+      user_id: 1,
+      user_name: email,
+      user_email: email,
+      user_password: hassPassword,
+      user_role: role._id,
+    });
+
+    if (newUser) {
+      const privateKey = crypto.randomBytes(64).toString("hex");
+      const publicKey = crypto.randomBytes(64).toString("hex");
+      const tokens = await createTokenPair(
+        {
+          userId: newUser._id,
+          email,
+        },
+        privateKey,
+        publicKey
+      );
+
+      const keyStore = await KeyTokenService.createKeyToken({
+        userId: newUser._id,
+        publicKey,
+        privateKey,
+        refreshToken: tokens.refreshToken,
+      });
+
+      if (!keyStore) {
+        throw new BadRequestError("Error: Public key string error");
+      }
+
+      return {
+        user: getInfoData({
+          fields: ["_id", "name", "email"],
+          object: newUser,
+        }),
+        tokens,
+      };
+    }
+
+    return {
+      message: "Verify email successfully",
+    };
+  }
+
+  static async newUser({ email = null, captcha = null }) {
+    // check if email is already registered
+    const user = await User.findOne({ email }).lean().exec();
+    if (user) {
+      throw new BadRequestError("Email already registered");
+    }
+
+    // check if captcha is valid
+    // send otp to emai
+    return {
+      message: "Send otp to email successfully",
+    };
+  }
+}
+
+module.exports = UserService();

package/templates/node-express/files/src/tests/inventory.test.js

@@ -0,0 +1,21 @@
+// inventory.test.js
+const redisPubSubService = require("../services/redisPubSub.service");
+
+class InventoryServiceTest {
+  constructor() {
+    // Subscribe to Redis channel
+    redisPubSubService.subscribe("purchase", function (channel, message) {
+      console.log("Received message:", message);
+      // Assuming InventoryServiceTest.updateInventory is static
+      InventoryServiceTest.updateInventory(JSON.parse(message));
+    });
+  }
+
+  static updateInventory({ productId, quantity }) {
+    console.log(
+      `Updating inventory for product ${productId} with quantity ${quantity}`
+    );
+  }
+}
+
+module.exports = new InventoryServiceTest();

package/templates/node-express/files/src/tests/message_queue/kafka/consumer.js

@@ -0,0 +1,23 @@
+const { Kafka, logLevel } = require("kafkajs");
+
+const kafka = new Kafka({
+  clientId: "my-app",
+  brokers: ["localhost:9092"],
+  logLevel: logLevel.name,
+});
+
+const consumer = kafka.consumer({ groupId: "test-group" });
+
+const runConsumer = async () => {
+  await consumer.connect();
+  await consumer.subscribe({ topic: "test-topic", fromBeginning: true });
+  await consumer.run({
+    eachMessage: async ({ topic, partition, message }) => {
+      console.log({
+        value: message.value.toString(),
+      });
+    },
+  });
+};
+
+runConsumer().catch((err) => console.log(err));

package/templates/node-express/files/src/tests/message_queue/kafka/producer.js

@@ -0,0 +1,21 @@
+const { Kafka, logLevel } = require("kafkajs");
+
+const kafka = new Kafka({
+  clientId: "my-app",
+  brokers: ["localhost:9092"],
+  logLevel: logLevel.NOTHING
+});
+
+const producer = kafka.producer();
+
+const runProducer = async () => {
+  await producer.connect();
+  await producer.send({
+    topic: "test-topic",
+    messages: [{ value: "Hello KafkaJS user!" }],
+  });
+
+  await producer.disconnect();
+};
+
+runProducer().catch((err) => console.log(err));

package/templates/node-express/files/src/tests/message_queue/rabbitMQ/consumer.js

@@ -0,0 +1,28 @@
+const amqp = require("amqplib");
+
+const runConsumer = async () => {
+  try {
+    const connection = await amqp.connect("amqp://localhost:5672");
+    const channel = await connection.createChannel();
+    const queueName = "test-topic";
+
+    await channel.assertQueue(queueName, {
+      durable: true,
+    });
+
+    channel.consume(
+      queueName,
+      (message) => {
+        console.log(`message_received:::${message.content.toString()}`);
+      },
+      {
+        // avoid dupliacte messages if client already received the message
+        noAck: true,
+      }
+    );
+  } catch (error) {
+    console.log("Error rabbitmq: ", error);
+  }
+};
+
+runConsumer().catch((err) => console.log(err));

package/templates/node-express/files/src/tests/message_queue/rabbitMQ/ordered.consumer.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const amqp = require("amqplib");
+
+const consumeOrderedMessages = async () => {
+  const connection = await amqp.connect("amqp://localhost:5672");
+  const channel = await connection.createChannel();
+  const queueName = "ordered_queue";
+
+  await channel.assertQueue(queueName, {
+    durable: true
+  });
+
+  // Set prefetch to 1 to ensure only one message is processed at a time until it is acknowledged
+  channel.prefetch(1);
+
+  channel.consume(queueName, (message) => {
+    const msg = message.content.toString();
+    setTimeout(() => {
+      console.log("Processed: ", msg);
+      channel.ack(message);
+    }, Math.random() * 1000);
+  });
+};
+
+consumeOrderedMessages().catch((err) => console.log(err));

package/templates/node-express/files/src/tests/message_queue/rabbitMQ/ordered.producer.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const amqp = require("amqplib");
+
+const produceOrderedMessages = async () => {
+  const connection = await amqp.connect("amqp://localhost:5672");
+  const channel = await connection.createChannel();
+  const queueName = "ordered_queue";
+
+  await channel.assertQueue(queueName, {
+    durable: true,
+  });
+
+  for (let i = 0; i < 10; i++) {
+    await channel.sendToQueue(
+      queueName,
+      Buffer.from(`Ordered Message:::${i}`),
+      {
+        persistent: true,
+      }
+    );
+    console.log(`message_ordered_sent:::${i}`);
+  }
+
+  setTimeout(() => {
+    connection.close();
+    console.log("Connection closed");
+  }, 1000);
+};
+
+produceOrderedMessages().catch((err) => console.log(err));