@hastehaul/common 1.0.11 → 1.0.12

package/build/connections-wrappers/redis-connection-wrapper.d.ts

@@ -1,9 +1,26 @@
 import IORedis from "ioredis";
+/**
+ * A wrapper class for the Redis client to manage connections and provide a centralized client instance.
+ */
 export declare class RedisWrapper {
     private _redisClient?;
     private host;
     private port;
+    /**
+     * Get the Redis client instance.
+     *
+     * @throws {Error} - Throws an error if the Redis client is accessed before connecting.
+     * @returns {IORedis} - The Redis client instance.
+     */
     get client(): IORedis;
+    /**
+     * Connect to the Redis server using the specified host and port.
+     *
+     * The client instance will be stored in the `_redisClient` property for later access.
+     */
     connect(): void;
 }
+/**
+ * Singleton instance of the RedisWrapper class to provide a centralized Redis client connection.
+ */
 export declare const redisWrapper: RedisWrapper;

package/build/connections-wrappers/redis-connection-wrapper.js

@@ -5,16 +5,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.redisWrapper = exports.RedisWrapper = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
+/**
+ * A wrapper class for the Redis client to manage connections and provide a centralized client instance.
+ */
 class RedisWrapper {
     constructor() {
         this.host = "customer-redis-srv";
         this.port = 6379;
     }
+    /**
+     * Get the Redis client instance.
+     *
+     * @throws {Error} - Throws an error if the Redis client is accessed before connecting.
+     * @returns {IORedis} - The Redis client instance.
+     */
     get client() {
         if (!this._redisClient)
             throw new Error("Cannot access Redis Client before connecting");
         return this._redisClient;
     }
+    /**
+     * Connect to the Redis server using the specified host and port.
+     *
+     * The client instance will be stored in the `_redisClient` property for later access.
+     */
     connect() {
         this._redisClient = new ioredis_1.default({ host: this.host, port: this.port, maxRetriesPerRequest: null });
         this._redisClient.on("connect", function () {
@@ -26,4 +40,7 @@ class RedisWrapper {
     }
 }
 exports.RedisWrapper = RedisWrapper;
+/**
+ * Singleton instance of the RedisWrapper class to provide a centralized Redis client connection.
+ */
 exports.redisWrapper = new RedisWrapper();

package/build/connections-wrappers/socket-connection-wrapper.d.ts

@@ -1,9 +1,28 @@
 /// <reference types="node" />
 import http from "http";
 import { Server } from 'socket.io';
+/**
+ * A wrapper class for the Socket.IO server to manage connections and provide a centralized server instance.
+ */
 export declare class SocketWrapper {
     protected _io?: Server;
-    get io(): Server<import("socket.io/dist/typed-events").DefaultEventsMap, import("socket.io/dist/typed-events").DefaultEventsMap, import("socket.io/dist/typed-events").DefaultEventsMap, any>;
+    /**
+     * Get the Socket.IO server instance.
+     *
+     * @throws {Error} - Throws an error if the Socket.IO server is accessed before connecting.
+     * @returns {Server} - The Socket.IO server instance.
+     */
+    get io(): Server;
+    /**
+     * Connect to the Socket.IO server using the specified HTTP server.
+     *
+     * The server instance will be stored in the `_io` property for later access.
+     *
+     * @param {http.Server} httpServer - The HTTP server instance to attach Socket.IO to.
+     */
     connect(httpServer: http.Server): void;
 }
+/**
+ * Singleton instance of the SocketWrapper class to provide a centralized Socket.IO server connection.
+ */
 export declare const socketWrapper: SocketWrapper;

package/build/connections-wrappers/socket-connection-wrapper.js

@@ -2,12 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.socketWrapper = exports.SocketWrapper = void 0;
 const socket_io_1 = require("socket.io");
+/**
+ * A wrapper class for the Socket.IO server to manage connections and provide a centralized server instance.
+ */
 class SocketWrapper {
+    /**
+     * Get the Socket.IO server instance.
+     *
+     * @throws {Error} - Throws an error if the Socket.IO server is accessed before connecting.
+     * @returns {Server} - The Socket.IO server instance.
+     */
     get io() {
         if (!this._io)
             throw new Error("Cannot access IO Client before connecting");
         return this._io;
     }
+    /**
+     * Connect to the Socket.IO server using the specified HTTP server.
+     *
+     * The server instance will be stored in the `_io` property for later access.
+     *
+     * @param {http.Server} httpServer - The HTTP server instance to attach Socket.IO to.
+     */
     connect(httpServer) {
         this._io = new socket_io_1.Server(httpServer, {
             path: "/socket/",
@@ -22,4 +38,7 @@ class SocketWrapper {
     }
 }
 exports.SocketWrapper = SocketWrapper;
+/**
+ * Singleton instance of the SocketWrapper class to provide a centralized Socket.IO server connection.
+ */
 exports.socketWrapper = new SocketWrapper();

package/build/middlewares/current-user.d.ts

@@ -1,2 +1,11 @@
 import { Request, Response, NextFunction } from "express";
+/**
+ * Middleware function to extract the current user from the request's Authorization header.
+ *
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ *
+ * @returns {Promise<void>} - A Promise that resolves once the user extraction is complete, but it is not used directly.
+ */
 export declare const currentUser: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/current-user.js

@@ -34,26 +34,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.currentUser = void 0;
 const jsonwebtoken_1 = __importStar(require("jsonwebtoken"));
+/**
+ * Middleware function to extract the current user from the request's Authorization header.
+ *
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ *
+ * @returns {Promise<void>} - A Promise that resolves once the user extraction is complete, but it is not used directly.
+ */
 const currentUser = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     let result = null;
     try {
+        // Extract the Bearer token from the Authorization header.
         const bearerToken = req.headers["authorization"];
         if (typeof bearerToken !== "undefined" && bearerToken) {
             const token = bearerToken.split(" ")[1];
             if (token) {
+                // Verify the JWT token and decode the user payload.
                 result = jsonwebtoken_1.default.verify(token, process.env.JWT_KEY.split("-").join(""));
             }
         }
+        // Attach the user payload to the request object for later use in the application.
         req.currentUser = result;
     }
     catch (err) {
+        // Handle errors related to token verification or expiration.
         if (err instanceof jsonwebtoken_1.TokenExpiredError) {
+            // If the token is expired, you may consider refreshing the token or taking appropriate actions.
+            // Uncomment the following line if you want to handle token expiration using the AuthController.
+            // await AuthController.refreshToken(req, res);
             // await AuthController.refreshToken(req, res)
         }
         else {
+            // If any other error occurs during token verification, set currentUser to null.
             req.currentUser = null;
         }
     }
+    // Call the next middleware in the chain.
     next();
 });
 exports.currentUser = currentUser;

package/build/middlewares/error-handler.d.ts

@@ -1,2 +1,10 @@
 import { NextFunction, Request, Response } from "express";
+/**
+ * Express error handling middleware to handle custom errors and provide appropriate responses.
+ *
+ * @param {Error} err - The error object that needs to be handled.
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ */
 export declare const errorHandler: (err: Error, req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/build/middlewares/error-handler.js

@@ -3,6 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = void 0;
 const custom_error_1 = require("../errors/custom-error");
 const enums_1 = require("../utils/enums");
+/**
+ * Express error handling middleware to handle custom errors and provide appropriate responses.
+ *
+ * @param {Error} err - The error object that needs to be handled.
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ */
 const errorHandler = (err, req, res, next) => {
     if (err instanceof custom_error_1.CustomError) {
         return res.status(err.statusCode).send({ errors: err.serializeErrors() });

package/build/utils/base_classes/jobs/base-producers.d.ts

@@ -1,7 +1,23 @@
 import { Queue } from "bullmq";
+/**
+ * Abstract class representing a Job Queue.
+ */
 export declare abstract class AbstractJobQueue {
     protected que: Queue;
     protected abstract jobName: string;
+    /**
+     * Creates an instance of AbstractJobQueue.
+     *
+     * @param {string} queueName - The name of the job queue.
+     */
     constructor(queueName: string);
+    /**
+   * Abstract method to add jobs to the job queue.
+   *
+   * This method should be implemented by subclasses to add specific jobs to the queue.
+   *
+   * @param {any} data - The data representing the job to be added to the queue.
+   * @returns {Promise<void>} - A Promise that resolves when the job is added to the queue successfully.
+   */
     abstract addJobs(data: any): Promise<void>;
 }

package/build/utils/base_classes/jobs/base-producers.js

@@ -3,9 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractJobQueue = void 0;
 const bullmq_1 = require("bullmq");
 const connections_wrappers_1 = require("../../../connections-wrappers");
-// Define the abstract class
+/**
+ * Abstract class representing a Job Queue.
+ */
 class AbstractJobQueue {
+    /**
+     * Creates an instance of AbstractJobQueue.
+     *
+     * @param {string} queueName - The name of the job queue.
+     */
     constructor(queueName) {
+        // Initialize the job queue with the provided name and a Redis connection from the redisWrapper.
         this.que = new bullmq_1.Queue(queueName, { connection: connections_wrappers_1.redisWrapper.client });
     }
 }

package/build/utils/base_classes/jobs/base-worker.d.ts

@@ -1,6 +1,22 @@
 import { Job, Worker } from "bullmq";
+/**
+ * Abstract class representing a worker for processing jobs from a Job Queue.
+ */
 export declare abstract class AbstractWorker {
     protected worker: Worker;
+    /**
+     * Creates an instance of AbstractWorker.
+     *
+     * @param {string} queueName - The name of the job queue that this worker will process jobs from.
+     */
     constructor(queueName: string);
+    /**
+     * Abstract method to process jobs retrieved from the job queue.
+     *
+     * This method should be implemented by subclasses to handle specific job processing logic.
+     *
+     * @param {Job} job - The job object representing the job to be processed.
+     * @returns {Promise<void>} - A Promise that resolves when the job processing is completed successfully.
+     */
     protected abstract process(job: Job): Promise<void>;
 }

package/build/utils/base_classes/jobs/base-worker.js

@@ -3,15 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractWorker = void 0;
 const bullmq_1 = require("bullmq");
 const connections_wrappers_1 = require("../../../connections-wrappers");
+/**
+ * Abstract class representing a worker for processing jobs from a Job Queue.
+ */
 class AbstractWorker {
+    /**
+     * Creates an instance of AbstractWorker.
+     *
+     * @param {string} queueName - The name of the job queue that this worker will process jobs from.
+     */
     constructor(queueName) {
+        // Create a worker instance with the provided queueName and bind the 'process' method to this worker.
         this.worker = new bullmq_1.Worker(queueName, this.process.bind(this), {
             connection: connections_wrappers_1.redisWrapper.client,
             autorun: false,
         });
+        // Handle errors that may occur during job processing.
         this.worker.on("error", (err) => {
             console.error(`${queueName} Error: `, err);
         });
+        // Start the worker in non-autorun mode, which means it won't start processing jobs automatically.
         console.log(" --- WORKER STARTED --- ", queueName);
         this.worker.run();
     }

package/build/utils/random-codes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generates random codes as an async function using await.
+ *
+ * @param {string} characters - The set of characters to use for generating codes.
+ * @param {number} numberOfCodes - The total number of codes to generate.
+ * @param {number} codeSize - The size of each individual code (number of characters).
+ * @param {boolean} includeHyphens - Whether to include hyphens between codes.
+ * @param {number} chunkSize - The number of codes to generate in each chunk (iteration).
+ *
+ * @returns {Promise<string>} - A Promise that resolves with the generated codes as a string.
+ */
+declare function generateRandomCodesAsync(characters: string, numberOfCodes: number, codeSize: number, includeHyphens: boolean, chunkSize: number): Promise<string>;

package/build/utils/random-codes.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/**
+ * Generates random codes as an async function using await.
+ *
+ * @param {string} characters - The set of characters to use for generating codes.
+ * @param {number} numberOfCodes - The total number of codes to generate.
+ * @param {number} codeSize - The size of each individual code (number of characters).
+ * @param {boolean} includeHyphens - Whether to include hyphens between codes.
+ * @param {number} chunkSize - The number of codes to generate in each chunk (iteration).
+ *
+ * @returns {Promise<string>} - A Promise that resolves with the generated codes as a string.
+ */
+function generateRandomCodesAsync(characters, numberOfCodes, codeSize, includeHyphens, chunkSize) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let codes = "";
+        let hyphen = includeHyphens ? "-" : "";
+        let chunkStart = 0;
+        let generatedCodes = new Set();
+        function generateChunk() {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (let i = chunkStart; i < chunkStart + chunkSize && i < numberOfCodes; i++) {
+                    let code = "";
+                    for (let j = 0; j < codeSize; j++) {
+                        code += characters.charAt(Math.floor(Math.random() * characters.length));
+                    }
+                    if (!generatedCodes.has(code)) {
+                        generatedCodes.add(code);
+                        codes += code + (i === numberOfCodes - 1 ? "" : hyphen);
+                    }
+                    else {
+                        i--;
+                    }
+                }
+                chunkStart += chunkSize;
+                if (chunkStart < numberOfCodes && generatedCodes.size < numberOfCodes) {
+                    yield generateChunk();
+                }
+            });
+        }
+        yield generateChunk();
+        return codes;
+    });
+}

package/build/utils/read-dir.js

@@ -39,13 +39,3 @@ function readDirectoryRecursive(dirPath, filter) {
     });
 }
 exports.readDirectoryRecursive = readDirectoryRecursive;
-// // Example usage:
-// const directoryPath = '/path/to/your/directory';
-// (async () => {
-//   try {
-//     const filteredFiles = await readDirectoryRecursive(directoryPath, (filePath) => filePath.endsWith('.txt'));
-//     console.log(filteredFiles);
-//   } catch (err) {
-//     console.error('Error occurred:', err);
-//   }
-// })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hastehaul/common",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",